@tachybase/module-multi-app 1.6.0 → 1.6.2

package/dist/node_modules/mariadb/lib/connection.js

@@ -1,7 +1,9 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2025 MariaDB Corporation Ab
+
 'use strict';
 
 const EventEmitter = require('events');
-const util = require('util');
 const Queue = require('denque');
 const Net = require('net');
 const PacketInputStream = require('./io/packet-input-stream');
@@ -14,19 +16,55 @@ const tls = require('tls');
 const Errors = require('./misc/errors');
 const Utils = require('./misc/utils');
 const Capabilities = require('./const/capabilities');
-const moment = require('moment-timezone');
+const ConnectionOptions = require('./config/connection-options');
 
 /*commands*/
-const Handshake = require('./cmd/handshake/handshake');
+const Authentication = require('./cmd/handshake/authentication');
 const Quit = require('./cmd/quit');
 const Ping = require('./cmd/ping');
 const Reset = require('./cmd/reset');
 const Query = require('./cmd/query');
-const BatchRewrite = require('./cmd/batch-rewrite');
+const Prepare = require('./cmd/prepare');
+const OkPacket = require('./cmd/class/ok-packet');
+const Execute = require('./cmd/execute');
+const ClosePrepare = require('./cmd/close-prepare');
 const BatchBulk = require('./cmd/batch-bulk');
-const Stream = require('./cmd/stream');
 const ChangeUser = require('./cmd/change-user');
 const { Status } = require('./const/connection_status');
+const LruPrepareCache = require('./lru-prepare-cache');
+const fsPromises = require('fs').promises;
+const Parse = require('./misc/parse');
+const Collations = require('./const/collations');
+const ConnOptions = require('./config/connection-options');
+
+const convertFixedTime = function (tz, conn) {
+  if (tz === 'UTC' || tz === 'Etc/UTC' || tz === 'Z' || tz === 'Etc/GMT') {
+    return '+00:00';
+  } else if (tz.startsWith('Etc/GMT') || tz.startsWith('GMT')) {
+    let tzdiff;
+    let negate;
+
+    // strangely Etc/GMT+8 = GMT-08:00 = offset -8
+    if (tz.startsWith('Etc/GMT')) {
+      tzdiff = tz.substring(7);
+      negate = !tzdiff.startsWith('-');
+    } else {
+      tzdiff = tz.substring(3);
+      negate = tzdiff.startsWith('-');
+    }
+    let diff = parseInt(tzdiff.substring(1));
+    if (isNaN(diff)) {
+      throw Errors.createFatalError(
+        `Automatic timezone setting fails. wrong Server timezone '${tz}' conversion to +/-HH:00 conversion.`,
+        Errors.ER_WRONG_AUTO_TIMEZONE,
+        conn.info
+      );
+    }
+    return (negate ? '-' : '+') + (diff >= 10 ? diff : '0' + diff) + ':00';
+  }
+  return tz;
+};
+const redirectUrlFormat = /(mariadb|mysql):\/\/(([^/@:]+)?(:([^/]+))?@)?(([^/:]+)(:([0-9]+))?)(\/([^?]+)(\?(.*))?)?$/;
 
 /**
  * New Connection instance.
@@ -39,9 +77,44 @@ const { Status } = require('./const/connection_status');
  * @fires Connection#error
  *
  */
-function Connection(options) {
+class Connection extends EventEmitter {
+  opts;
+  sendQueue = new Queue();
+  receiveQueue = new Queue();
+  waitingAuthenticationQueue = new Queue();
+  status = Status.NOT_CONNECTED;
+  socket = null;
+  timeout = null;
+  addCommand;
+  streamOut;
+  streamIn;
+  info;
+  prepareCache;
+
+  constructor(options) {
+    super();
+
+    this.opts = Object.assign(new EventEmitter(), options);
+    this.info = new ConnectionInformation(this.opts, this.redirect.bind(this));
+    this.prepareCache =
+      this.opts.prepareCacheLength > 0 ? new LruPrepareCache(this.info, this.opts.prepareCacheLength) : null;
+    this.addCommand = this.addCommandQueue;
+    this.streamOut = new PacketOutputStream(this.opts, this.info);
+    this.streamIn = new PacketInputStream(
+      this.unexpectedPacket.bind(this),
+      this.receiveQueue,
+      this.streamOut,
+      this.opts,
+      this.info
+    );
+
+    this.on('close_prepare', this._closePrepare.bind(this));
+    this.escape = Utils.escape.bind(this, this.opts, this.info);
+    this.escapeId = Utils.escapeId.bind(this, this.opts, this.info);
+  }
+
   //*****************************************************************
-  // public API functions
+  // public methods
   //*****************************************************************
 
   /**
@@ -49,259 +122,518 @@ function Connection(options) {
    *
    * @returns {Promise} promise
    */
-  this.connect = () => {
-    switch (_status) {
-      case Status.NOT_CONNECTED:
-        _status = Status.CONNECTING;
-        return new Promise(function (resolve, reject) {
-          _registerHandshakeCmd(resolve, reject);
-        });
+  connect() {
+    const conn = this;
+    this.status = Status.CONNECTING;
+    const authenticationParam = {
+      opts: this.opts
+    };
 
-      case Status.CLOSING:
-      case Status.CLOSED:
-        return Promise.reject(
-          Errors.createError(
-            'Connection closed',
-            null,
-            true,
-            info,
-            '08S01',
-            Errors.ER_CONNECTION_ALREADY_CLOSED
-          )
-        );
+    return new Promise(function (resolve, reject) {
+      conn.connectRejectFct = reject;
+      conn.connectResolveFct = resolve;
+
+      // Add a handshake to msg queue
+      const authentication = new Authentication(
+        authenticationParam,
+        conn.authSucceedHandler.bind(conn),
+        conn.authFailHandler.bind(conn),
+        conn.createSecureContext.bind(conn),
+        conn.getSocket.bind(conn)
+      );
 
-      case Status.CONNECTING:
-      case Status.AUTHENTICATING:
-        return Promise.reject(
-          Errors.createError(
-            'Connection is already connecting',
-            null,
-            true,
-            info,
-            '08S01',
-            Errors.ER_ALREADY_CONNECTING
-          )
-        );
-    }
-    //status Connected
-    return Promise.resolve(this);
-  };
+      // Capture stack trace for better error reporting
+      Error.captureStackTrace(authentication);
+
+      authentication.once('end', () => {
+        conn.receiveQueue.shift();
+
+        // conn.info.collation might not be initialized
+        // in case of handshake throwing error
+        if (!conn.opts.collation && conn.info.collation) {
+          conn.opts.emit('collation', conn.info.collation);
+        }
+
+        process.nextTick(conn.nextSendCmd.bind(conn));
+      });
+
+      conn.receiveQueue.push(authentication);
+      conn.streamInitSocket.call(conn);
+    });
+  }
 
   /**
-   * Permit to change user during connection.
-   * All user variables will be reset, Prepare commands will be released.
-   * !!! mysql has a bug when CONNECT_ATTRS capability is set, that is default !!!!
+   * Execute a prepared statement with the given parameters
    *
-   * @param options   connection options
-   * @returns {Promise} promise
+   * @param {Object} cmdParam - Command parameters
+   * @param {Object} prepare - Prepared statement
+   * @param {Function} resolve - Promise resolve function
+   * @param {Function} reject - Promise reject function
    */
-  this.changeUser = (options) => {
-    if (!info.isMariaDB()) {
-      return Promise.reject(
-        Errors.createError(
-          'method changeUser not available for MySQL server due to Bug #83472',
-          null,
-          false,
-          info,
-          '0A000',
-          Errors.ER_MYSQL_CHANGE_USER_BUG
-        )
-      );
+  executePromise(cmdParam, prepare, resolve, reject) {
+    const cmd = new Execute(resolve, this._logAndReject.bind(this, reject), this.opts, cmdParam, prepare);
+    this.addCommand(cmd, true);
+  }
+
+  /**
+   * Execute a batch of the same SQL statement with different parameter sets
+   *
+   * @param {Object|String} cmdParam - SQL statement or options object
+   * @param {function} resolve - promise resolve function
+   * @param {function} reject - promise reject function
+   */
+  batch(cmdParam, resolve, reject) {
+    // Validate SQL parameter
+    if (!cmdParam.sql) {
+      return this.handleMissingSqlError(reject);
     }
 
-    return new Promise(function (resolve, reject) {
-      _addCommand(
-        new ChangeUser(
-          options,
-          (res) => {
-            if (options && options.collation) opts.collation = options.collation;
-            resolve(res);
-          },
-          _authFailHandler.bind(this, reject),
-          _addCommand.bind(this)
-        )
-      );
-    });
-  };
+    // Validate values parameter
+    if (!cmdParam.values) {
+      return this.handleMissingValuesError(cmdParam, reject);
+    }
+
+    // Execute the batch operation
+    this.prepare(
+      cmdParam,
+      (prepare) => this.executeBatch(cmdParam, prepare, resolve, reject),
+      (err) => this._logAndReject(reject, err)
+    );
+  }
 
   /**
-   * Start transaction
+   * Handle missing SQL parameter error
    *
-   * @returns {Promise} promise
+   * @param {Function} reject - Promise reject function
+   * @private
    */
-  this.beginTransaction = () => {
-    return this.query('START TRANSACTION');
-  };
+  handleMissingSqlError(reject) {
+    const err = Errors.createError(
+      'sql parameter is mandatory',
+      Errors.ER_UNDEFINED_SQL,
+      this.info,
+      'HY000',
+      null,
+      false
+    );
+
+    // Add stack trace for better debugging
+    Error.captureStackTrace(err, this.handleMissingSqlError);
+    this._logAndReject(reject, err);
+  }
 
   /**
-   * Commit a transaction.
+   * Handle missing values parameter error
    *
-   * @returns {Promise} command if commit was needed only
+   * @param {Object} cmdParam - Command parameters
+   * @param {Function} reject - Promise reject function
+   * @private
    */
-  this.commit = () => {
-    return _changeTransaction('COMMIT');
-  };
+  handleMissingValuesError(cmdParam, reject) {
+    const sql = cmdParam.sql;
+    // Truncate SQL for debug output if it's too long
+    const debugSql = sql.length > this.opts.debugLen ? sql.substring(0, this.opts.debugLen) + '...' : sql;
+
+    const err = Errors.createError(
+      'Batch must have values set',
+      Errors.ER_BATCH_WITH_NO_VALUES,
+      this.info,
+      'HY000',
+      debugSql,
+      false,
+      cmdParam.stack
+    );
+    this._logAndReject(reject, err);
+  }
 
   /**
-   * Roll back a transaction.
+   * Execute batch operation with prepared statement
    *
-   * @returns {Promise} promise
+   * @param {Object} cmdParam - Command parameters
+   * @param {Object} prepare - Prepared statement
+   * @param {Function} resolve - Promise resolve function
+   * @param {Function} reject - Promise reject function
+   * @private
    */
-  this.rollback = () => {
-    return _changeTransaction('ROLLBACK');
-  };
+  executeBatch(cmdParam, prepare, resolve, reject) {
+    const usePlaceHolder = (cmdParam.opts && cmdParam.opts.namedPlaceholders) || this.opts.namedPlaceholders;
+    let values = this.formatBatchValues(cmdParam.values, usePlaceHolder, prepare.parameterCount);
+    cmdParam.values = values;
+
+    // Determine if bulk protocol can be used
+    const useBulk = this._canUseBulk(values, cmdParam.opts);
+
+    if (useBulk) {
+      this.executeBulkPromise(cmdParam, prepare, this.opts, resolve, reject);
+    } else {
+      this.executeIndividualBatches(cmdParam, prepare, resolve, reject);
+    }
+  }
 
   /**
-   * Execute query using text protocol.
+   * Execute bulk operation using specialized bulk protocol
    *
-   * @param sql     sql parameter Object can be used to supersede default option.
-   *                Object must then have sql property.
-   * @param values  object / array of placeholder values (not mandatory)
-   * @returns {Promise} promise
+   * @param {Object} cmdParam - Command parameters
+   * @param {Object} prepare - Prepared statement
+   * @param {Object} opts - Options
+   * @param {Function} resolve - Promise resolve function
+   * @param {Function} reject - Promise reject function
+   * @private
    */
-  this._queryPromise = (sql, values) => {
-    let _cmdOpt,
-      _sql,
-      _values = values;
-    if (typeof sql === 'object') {
-      _cmdOpt = sql;
-      _sql = _cmdOpt.sql;
-      if (_cmdOpt.values) _values = _cmdOpt.values;
-    } else {
-      _sql = sql;
+  executeBulkPromise(cmdParam, prepare, opts, resolve, reject) {
+    const cmd = new BatchBulk(
+      (res) => {
+        prepare.close();
+        return resolve(res);
+      },
+      (err) => {
+        prepare.close();
+        if (opts.logger.error) opts.logger.error(err);
+        reject(err);
+      },
+      opts,
+      prepare,
+      cmdParam
+    );
+    this.addCommand(cmd, true);
+  }
+
+  /**
+   * Format batch values into the correct structure
+   *
+   * @param {Array} values - Original values array
+   * @param {Boolean} usePlaceHolder - Whether named placeholders are used
+   * @param {Number} parameterCount - Number of parameters in prepared statement
+   * @returns {Array} Formatted values array
+   * @private
+   */
+  formatBatchValues(values, usePlaceHolder, parameterCount) {
+    // If values is not an array, wrap it
+    if (!Array.isArray(values)) {
+      return [[values]];
     }
 
-    return new Promise(function (resolve, reject) {
-      const cmd = new Query(resolve, reject, _cmdOpt, opts, _sql, _values);
-      if (opts.trace) Error.captureStackTrace(cmd);
-      _addCommand(cmd);
-    });
-  };
+    // For named placeholders, return as is
+    if (usePlaceHolder) {
+      return values;
+    }
+
+    // If already in correct format (array of arrays), return as is
+    if (Array.isArray(values[0])) {
+      return values;
+    }
+
+    // If only one parameter expected, convert flat array to array of single-item arrays
+    if (parameterCount === 1) {
+      // Pre-allocate result array for better performance
+      const result = new Array(values.length);
+      for (let i = 0; i < values.length; i++) {
+        result[i] = [values[i]];
+      }
+      return result;
+    }
+
+    // Single set of parameters for multiple placeholders
+    return [values];
+  }
 
   /**
-   * Execute batch using text protocol.
+   * Execute individual batch operations when bulk protocol can't be used
    *
-   * @param sql     sql parameter Object can be used to supersede default option.
-   *                Object must then have sql property.
-   * @param initialValues  object / array of placeholder values (not mandatory)
-   * @returns {Promise} promise
+   * @param {Object} cmdParam - Command parameters
+   * @param {Object} prepare - Prepared statement
+   * @param {Function} resolve - Promise resolve function
+   * @param {Function} reject - Promise reject function
+   * @private
    */
-  this.batch = (sql, initialValues) => {
-    let _options,
-      _sql,
-      _values = initialValues;
-    if (typeof sql === 'object') {
-      _options = sql;
-      _sql = _options.sql;
-      if (_options.values) _values = _options.values;
-    } else {
-      _sql = sql;
+  executeIndividualBatches(cmdParam, prepare, resolve, reject) {
+    const results = [];
+    const batchSize = 1000; // Process in chunks to avoid memory issues
+    const totalBatches = Math.ceil(cmdParam.values.length / batchSize);
+
+    // Execute by chunks to avoid excessive memory usage
+    this.executeBatchChunk(cmdParam, prepare, 0, batchSize, totalBatches, results, resolve, reject);
+  }
+
+  /**
+   * Execute a chunk of the batch operations
+   *
+   * @param {Object} cmdParam - Command parameters
+   * @param {Object} prepare - Prepared statement
+   * @param {Number} chunkIndex - Current chunk index
+   * @param {Number} batchSize - Size of each batch chunk
+   * @param {Number} totalBatches - Total number of chunks
+   * @param {Array} results - Accumulated results
+   * @param {Function} resolve - Promise resolve function
+   * @param {Function} reject - Promise reject function
+   * @private
+   */
+  executeBatchChunk(cmdParam, prepare, chunkIndex, batchSize, totalBatches, results, resolve, reject) {
+    const values = cmdParam.values;
+    const startIdx = chunkIndex * batchSize;
+    const endIdx = Math.min(startIdx + batchSize, values.length);
+    const executes = [];
+
+    // Create execute promises for this chunk
+    for (let i = startIdx; i < endIdx; i++) {
+      executes.push(prepare.execute(values[i], cmdParam.opts, null, cmdParam.stack));
     }
 
-    if (!_values) {
-      return Promise.reject(
-        Errors.createError(
-          'Batch must have values set',
-          _sql,
-          false,
-          info,
-          'HY000',
-          Errors.ER_BATCH_WITH_NO_VALUES
-        )
-      );
+    // Execute all promises in this chunk
+    Promise.all(executes)
+      .then(
+        (chunkResults) => {
+          // Add results from this chunk to accumulated results
+          results.push(...chunkResults);
+
+          // If this was the last chunk, process results
+          if (chunkIndex === totalBatches - 1) {
+            const cmdOpt = Object.assign({}, this.opts, cmdParam.opts);
+            this.processBatchResults(results, cmdOpt, cmdParam, resolve);
+            prepare.close();
+          } else {
+            // Process next chunk
+            setImmediate(() => {
+              this.executeBatchChunk(
+                cmdParam,
+                prepare,
+                chunkIndex + 1,
+                batchSize,
+                totalBatches,
+                results,
+                resolve,
+                reject
+              );
+            });
+          }
+        },
+        (err) => {
+          prepare.close();
+          reject(err);
+        }
+      )
+      .catch((err) => {
+        prepare.close();
+        reject(err);
+      });
+  }
+
+  /**
+   * Process batch results from individual executions
+   *
+   * @param {Array} results - Array of individual results
+   * @param {Object} cmdOpt - Command options
+   * @param {Object} cmdParam - Command parameters
+   * @param {Function} resolve - Promise resolve function
+   * @private
+   */
+  processBatchResults(results, cmdOpt, cmdParam, resolve) {
+    // Handle empty results case
+    if (!results.length) {
+      resolve(cmdOpt.metaAsArray ? [[], []] : []);
+      return;
     }
 
-    const vals = Array.isArray(_values) ? _values : [_values];
+    // Return full results when requested
+    const fullResult = cmdOpt.fullResult === undefined || cmdOpt.fullResult;
+    if (fullResult) {
+      if (cmdOpt.metaAsArray) {
+        const aggregateResults = results.reduce((accumulator, currentValue) => {
+          if (Array.isArray(currentValue[0])) {
+            accumulator.push(...currentValue[0]);
+          } else if (currentValue[0] instanceof OkPacket) {
+            accumulator.push(currentValue[0]);
+          } else {
+            accumulator.push([currentValue[0]]);
+          }
+          return accumulator;
+        }, []);
+        const meta = results[0][1];
+        resolve([aggregateResults, meta]);
+      } else {
+        const aggregateResults = results.reduce((accumulator, currentValue) => {
+          if (currentValue instanceof OkPacket) {
+            accumulator.push(currentValue);
+          } else if (!cmdOpt.rowsAsArray && Array.isArray(currentValue[0])) {
+            accumulator.push(...currentValue[0]);
+          } else {
+            accumulator.push(currentValue[0]);
+          }
+          return accumulator;
+        }, []);
+        const meta = results[0].meta;
+        Object.defineProperty(aggregateResults, 'meta', {
+          value: meta,
+          writable: true,
+          enumerable: cmdOpt.metaEnumerable
+        });
+        resolve(aggregateResults);
+      }
+      return;
+    }
 
-    return new Promise(function (resolve, reject) {
-      let useBulk = canUseBulk(vals);
+    // Get first result to determine result type
+    const firstResult = cmdOpt.metaAsArray ? results[0][0] : results[0];
 
-      const cmd = useBulk
-        ? new BatchBulk(resolve, reject, _options, opts, _sql, vals)
-        : new BatchRewrite(resolve, reject, _options, opts, _sql, vals);
-      if (opts.trace) Error.captureStackTrace(cmd);
-      _addCommand(cmd);
-    });
-  };
+    // Process based on result type
+    if (firstResult instanceof OkPacket) {
+      this.aggregateOkPackets(results, cmdOpt, resolve);
+    } else {
+      this.aggregateResultSets(results, cmdOpt, resolve);
+    }
+  }
 
   /**
-   * Execute query returning a Readable Object that will emit columns/data/end/error events
-   * to permit streaming big result-set
+   * Aggregate OK packets from multiple executions
    *
-   * @param sql     sql parameter Object can be used to supersede default option.
-   *                Object must then have sql property.
-   * @param values  object / array of placeholder values (not mandatory)
-   * @returns {Readable}
+   * @param {Array} results - Array of individual results
+   * @param {Object} cmdOpt - Command options
+   * @param {Function} resolve - Promise resolve function
+   * @private
    */
-  this.queryStream = (sql, values) => {
-    let _cmdOpt,
-      _sql,
-      _values = values;
-    if (typeof sql === 'object') {
-      _cmdOpt = sql;
-      _sql = _cmdOpt.sql;
-      if (sql.values) _values = sql.values;
+  aggregateOkPackets(results, cmdOpt, resolve) {
+    // Get first packet's insertId and last packet's warning status
+    const insertId = results[0].insertId;
+    const warningStatus = results[results.length - 1].warningStatus;
+    let affectedRows = 0;
+
+    if (cmdOpt.metaAsArray) {
+      // Use reduce for better performance with large result sets
+      affectedRows = results.reduce((sum, result) => sum + result[0].affectedRows, 0);
+      resolve([new OkPacket(affectedRows, insertId, warningStatus), []]);
     } else {
-      _sql = sql;
+      affectedRows = results.reduce((sum, result) => sum + result.affectedRows, 0);
+      resolve(new OkPacket(affectedRows, insertId, warningStatus));
     }
+  }
+
+  /**
+   * Aggregate result sets from multiple executions
+   *
+   * @param {Array} results - Array of individual results
+   * @param {Object} cmdOpt - Command options
+   * @param {Function} resolve - Promise resolve function
+   * @private
+   */
+  aggregateResultSets(results, cmdOpt, resolve) {
+    if (cmdOpt.metaAsArray) {
+      // Calculate total length to avoid resizing
+      const totalLength = results.reduce((sum, row) => sum + (row[0]?.length || 0), 0);
+      const rs = new Array(totalLength);
+
+      // Efficiently copy all results into a single array
+      let index = 0;
+      for (const row of results) {
+        if (row[0] && row[0].length) {
+          const rowData = row[0];
+          for (let i = 0; i < rowData.length; i++) {
+            rs[index++] = rowData[i];
+          }
+        }
+      }
+
+      resolve([rs.slice(0, index), results[0][1]]);
+    } else {
+      // Calculate total length to avoid resizing
+      const totalLength = results.reduce((sum, row) => sum + (Array.isArray(row) ? row.length : 0), 0);
+      const rs = new Array(totalLength);
+
+      // Efficiently copy all results into a single array
+      let index = 0;
+      for (const row of results) {
+        if (Array.isArray(row) && row.length) {
+          for (let i = 0; i < row.length; i++) {
+            rs[index++] = row[i];
+          }
+        }
+      }
+
+      // Create final result array and add metadata
+      const finalResult = rs.slice(0, index);
 
-    const cmd = new Stream(_cmdOpt, opts, _sql, _values, _socket);
-    if (opts.trace) Error.captureStackTrace(cmd);
-    _addCommand(cmd);
-    return cmd.inStream;
-  };
+      // Add metadata as non-enumerable property
+      if (results[0] && results[0].meta) {
+        Object.defineProperty(finalResult, 'meta', {
+          value: results[0].meta,
+          writable: true,
+          enumerable: cmdOpt.metaEnumerable
+        });
+      }
+
+      resolve(finalResult);
+    }
+  }
 
   /**
    * Send an empty MySQL packet to ensure connection is active, and reset @@wait_timeout
-   * @param timeout (optional) timeout value in ms. If reached, throw error and close connection
-   * @returns {Promise} promise
+   * @param {Object} cmdParam - command context
+   * @param {Function} resolve - success function
+   * @param {Function} reject - rejection function
    */
-  this.ping = (timeout) => {
-    return new Promise(function (resolve, reject) {
-      if (timeout) {
-        if (timeout < 0) {
-          reject(
-            Errors.createError(
-              'Ping cannot have negative timeout value',
-              null,
-              false,
-              info,
-              '0A000',
-              Errors.ER_BAD_PARAMETER_VALUE
-            )
-          );
-          return;
+  ping(cmdParam, resolve, reject) {
+    // Handle custom timeout if provided
+    if (cmdParam.opts && cmdParam.opts.timeout !== undefined) {
+      // Validate timeout value
+      if (cmdParam.opts.timeout < 0) {
+        const err = Errors.createError(
+          'Ping cannot have negative timeout value',
+          Errors.ER_BAD_PARAMETER_VALUE,
+          this.info,
+          '0A000'
+        );
+        this._logAndReject(reject, err);
+        return;
+      }
+
+      let timeoutRef = setTimeout(() => {
+        // If timeout occurs, mark variable as cleared to avoid double resolving
+        timeoutRef = undefined;
+
+        // Create error with proper details
+        const err = Errors.createFatalError('Ping timeout', Errors.ER_PING_TIMEOUT, this.info, '0A000');
+
+        // Close connection properly
+        this.addCommand = this.addCommandDisabled;
+        clearTimeout(this.timeout);
+
+        if (this.status !== Status.CLOSING && this.status !== Status.CLOSED) {
+          this.sendQueue.clear();
+          this.status = Status.CLOSED;
+          this.socket.destroy();
         }
-        const tOut = setTimeout(() => {
-          reject(
-            Errors.createError('Ping timeout', null, true, info, '0A000', Errors.ER_PING_TIMEOUT)
-          );
-          // close connection
-          _addCommand = _addCommandDisabled;
-          clearTimeout(_timeout);
-          if (_status !== Status.CLOSING && _status !== Status.CLOSED) {
-            _sendQueue.clear();
-            _status = Status.CLOSED;
-            _socket.destroy();
-          }
-          _clear();
-        }, timeout);
-        return _addCommand(
-          new Ping(
-            () => {
-              clearTimeout(tOut);
+
+        this.clear();
+        this._logAndReject(reject, err);
+      }, cmdParam.opts.timeout);
+
+      // Create ping command with wrapped callbacks to handle timeout
+      this.addCommand(
+        new Ping(
+          cmdParam,
+          () => {
+            // Successful ping response - clear timeout if it hasn't fired yet
+            if (timeoutRef) {
+              clearTimeout(timeoutRef);
               resolve();
-            },
-            (err) => {
-              clearTimeout(tOut);
-              reject(err);
             }
-          )
-        );
-      }
-      return _addCommand(new Ping(resolve, reject));
-    });
-  };
+          },
+          (err) => {
+            // Error during ping - clear timeout if it hasn't fired yet
+            if (timeoutRef) {
+              clearTimeout(timeoutRef);
+              this._logAndReject(reject, err);
+            }
+          }
+        ),
+        true
+      );
+
+      return;
+    }
+
+    // Simple ping without custom timeout
+    this.addCommand(new Ping(cmdParam, resolve, reject), true);
+  }
 
   /**
    * Send a reset command that will
@@ -311,165 +643,163 @@ function Connection(options) {
    * - delete user variables
    * - remove temporary tables
    * - remove all PREPARE statement
-   *
-   * @returns {Promise} promise
    */
-  this.reset = () => {
+  reset(cmdParam, resolve, reject) {
     if (
-      (info.isMariaDB() && info.hasMinVersion(10, 2, 4)) ||
-      (!info.isMariaDB() && info.hasMinVersion(5, 7, 3))
+      (this.info.isMariaDB() && this.info.hasMinVersion(10, 2, 4)) ||
+      (!this.info.isMariaDB() && this.info.hasMinVersion(5, 7, 3))
     ) {
-      return new Promise(function (resolve, reject) {
-        return _addCommand(new Reset(resolve, reject));
-      });
+      const conn = this;
+      const resetCmd = new Reset(
+        cmdParam,
+        () => {
+          if (conn.prepareCache) conn.prepareCache.reset();
+          let prom = Promise.resolve();
+          // re-execute init query / session query timeout
+          prom
+            .then(conn.handleCharset.bind(conn))
+            .then(conn.handleTimezone.bind(conn))
+            .then(conn.executeInitQuery.bind(conn))
+            .then(conn.executeSessionTimeout.bind(conn))
+            .then(resolve)
+            .catch(reject);
+        },
+        reject
+      );
+      this.addCommand(resetCmd, true);
+      return;
     }
-    return Promise.reject(
-      new Error(
-        'Reset command not permitted for server ' +
-          this.info.serverVersion +
-          ' (requires server MariaDB version 10.2.4+ or MySQL 5.7.3+)'
-      )
+
+    const err = new Error(
+      `Reset command not permitted for server ${this.info.serverVersion.raw} (requires server MariaDB version 10.2.4+ or MySQL 5.7.3+)`
     );
-  };
+    err.stack = cmdParam.stack;
+    this._logAndReject(reject, err);
+  }
 
   /**
    * Indicates the state of the connection as the driver knows it
    * @returns {boolean}
    */
-  this.isValid = () => {
-    return _status === Status.CONNECTED;
-  };
+  isValid() {
+    return this.status === Status.CONNECTED;
+  }
 
   /**
    * Terminate connection gracefully.
-   *
-   * @returns {Promise} promise
-   */
-  this.end = () => {
-    _addCommand = _addCommandDisabled;
-    clearTimeout(_timeout);
-
-    if (
-      _status !== Status.CLOSING &&
-      _status !== Status.CLOSED &&
-      _status !== Status.NOT_CONNECTED
-    ) {
-      _status = Status.CLOSING;
-      return new Promise(function (resolve, reject) {
-        const ended = () => {
-          _status = Status.CLOSED;
-          _socket.destroy();
-          _socket.unref();
-          _clear();
-          _receiveQueue.clear();
-          resolve();
-        };
-        const quitCmd = new Quit(ended, ended);
-        _sendQueue.push(quitCmd);
-        _receiveQueue.push(quitCmd);
-        if (_sendQueue.length === 1) {
-          process.nextTick(_nextSendCmd.bind(this));
-        }
-      });
-    }
-    return Promise.resolve();
-  };
-
-  /**
-   * Alias for destroy.
    */
-  this.close = function () {
-    this.destroy();
-  };
+  end(cmdParam, resolve, reject) {
+    this.addCommand = this.addCommandDisabled;
+    clearTimeout(this.timeout);
+
+    if (this.status < Status.CLOSING && this.status !== Status.NOT_CONNECTED) {
+      this.status = Status.CLOSING;
+      const ended = () => {
+        this.status = Status.CLOSED;
+        this.socket.destroy();
+        this.socket.unref();
+        this.clear();
+        this.receiveQueue.clear();
+        resolve();
+      };
+      const quitCmd = new Quit(cmdParam, ended, ended);
+      this.sendQueue.push(quitCmd);
+      this.receiveQueue.push(quitCmd);
+      if (this.sendQueue.length === 1) {
+        process.nextTick(this.nextSendCmd.bind(this));
+      }
+    } else resolve();
+  }
 
   /**
    * Force connection termination by closing the underlying socket and killing server process if any.
    */
-  this.destroy = () => {
-    _addCommand = _addCommandDisabled;
-    clearTimeout(_timeout);
-    if (_status !== Status.CLOSING && _status !== Status.CLOSED) {
-      _status = Status.CLOSING;
-      _sendQueue.clear();
-      if (_receiveQueue.length > 0) {
+  destroy() {
+    this.addCommand = this.addCommandDisabled;
+    clearTimeout(this.timeout);
+    if (this.status < Status.CLOSING) {
+      this.status = Status.CLOSING;
+      this.sendQueue.clear();
+      if (this.receiveQueue.length > 0) {
         //socket is closed, but server may still be processing a huge select
         //only possibility is to kill process by another thread
         //TODO reuse a pool connection to avoid connection creation
         const self = this;
-        const killCon = new Connection(opts);
+
+        // relying on IP in place of DNS to ensure using same server
+        const remoteAddress = this.socket.remoteAddress;
+        const connOption = remoteAddress ? Object.assign({}, this.opts, { host: remoteAddress }) : this.opts;
+
+        const killCon = new Connection(connOption);
         killCon
           .connect()
           .then(() => {
             //*************************************************
             //kill connection
             //*************************************************
-            const killResHandler = () => {
-              const destroyError = Errors.createError(
+            new Promise(killCon.query.bind(killCon, { sql: `KILL ${self.info.threadId}` })).finally((err) => {
+              const destroyError = Errors.createFatalError(
                 'Connection destroyed, command was killed',
-                null,
-                true,
-                info,
-                '08S01',
-                Errors.ER_CMD_NOT_EXECUTED_DESTROYED
+                Errors.ER_CMD_NOT_EXECUTED_DESTROYED,
+                self.info
               );
-              socketErrorDispatchToQueries(destroyError);
-              process.nextTick(() => {
-                if (_socket) _socket.destroy();
-              });
-              _status = Status.CLOSED;
-              killCon.end().catch(() => {});
-            };
-
-            killCon
-              .query('KILL ' + info.threadId)
-              .then(killResHandler)
-              .catch(killResHandler);
+              if (self.opts.logger.error) self.opts.logger.error(destroyError);
+              self.socketErrorDispatchToQueries(destroyError);
+              if (self.socket) {
+                const sok = self.socket;
+                process.nextTick(() => {
+                  sok.destroy();
+                });
+              }
+              self.status = Status.CLOSED;
+              self.clear();
+              new Promise(killCon.end.bind(killCon)).catch(() => {});
+            });
           })
-          .catch((err) => {
+          .catch(() => {
             //*************************************************
             //failing to create a kill connection, end normally
             //*************************************************
             const ended = () => {
-              let sock = _socket;
-              _clear();
-              _status = Status.CLOSED;
-              setImmediate(resolve);
+              let sock = self.socket;
+              self.clear();
+              self.status = Status.CLOSED;
               sock.destroy();
-              _receiveQueue.clear();
+              self.receiveQueue.clear();
             };
             const quitCmd = new Quit(ended, ended);
-            _sendQueue.push(quitCmd);
-            _receiveQueue.push(quitCmd);
-            if (_sendQueue.length === 1) {
-              process.nextTick(_nextSendCmd.bind(self));
+            self.sendQueue.push(quitCmd);
+            self.receiveQueue.push(quitCmd);
+            if (self.sendQueue.length === 1) {
+              process.nextTick(self.nextSendCmd.bind(self));
             }
           });
       } else {
-        _status = Status.CLOSED;
-        _socket.destroy();
+        this.status = Status.CLOSED;
+        this.socket.destroy();
+        this.clear();
       }
     }
-    _clear();
-  };
+  }
 
-  this.pause = () => {
-    _socket.pause();
-  };
+  pause() {
+    this.socket.pause();
+  }
 
-  this.resume = () => {
-    _socket.resume();
-  };
+  resume() {
+    this.socket.resume();
+  }
 
-  this.format = (sql, values) => {
-    throw Errors.createError(
+  format(sql, values) {
+    const err = Errors.createError(
       '"Connection.format intentionally not implemented. please use Connection.query(sql, values), it will be more secure and faster',
-      null,
-      false,
-      info,
-      '0A000',
-      Errors.ER_NOT_IMPLEMENTED_FORMAT
+      Errors.ER_NOT_IMPLEMENTED_FORMAT,
+      this.info,
+      '0A000'
     );
-  };
+    if (this.opts.logger.error) this.opts.logger.error(err);
+    throw err;
+  }
 
   //*****************************************************************
   // additional public methods
@@ -480,594 +810,560 @@ function Connection(options) {
    *
    * @returns {*}
    */
-  this.serverVersion = () => {
-    if (!info.serverVersion)
-      throw new Error('cannot know if server information until connection is established');
-    return info.serverVersion.raw;
-  };
+  serverVersion() {
+    if (!this.info.serverVersion) {
+      const err = new Error('cannot know if server information until connection is established');
+      if (this.opts.logger.error) this.opts.logger.error(err);
+      throw err;
+    }
+
+    return this.info.serverVersion.raw;
+  }
 
   /**
    * Change option "debug" during connection.
    * @param val   debug value
    */
-  this.debug = (val) => {
-    opts.debug = val;
-    opts.emit('debug', opts.logPackets, opts.debug);
-  };
-
-  this.debugCompress = (val) => {
-    opts.debugCompress = val;
-  };
+  debug(val) {
+    if (typeof val === 'boolean') {
+      if (val && !this.opts.logger.network) this.opts.logger.network = console.log;
+    } else if (typeof val === 'function') {
+      this.opts.logger.network = val;
+    }
+    this.opts.emit('debug', val);
+  }
+
+  debugCompress(val) {
+    if (val) {
+      if (typeof val === 'boolean') {
+        this.opts.debugCompress = val;
+        if (val && !this.opts.logger.network) this.opts.logger.network = console.log;
+      } else if (typeof val === 'function') {
+        this.opts.debugCompress = true;
+        this.opts.logger.network = val;
+      }
+    } else this.opts.debugCompress = false;
+  }
 
   //*****************************************************************
   // internal public testing methods
   //*****************************************************************
 
-  function TestMethods() {}
-
-  TestMethods.prototype.getCollation = () => {
-    return opts.collation;
-  };
-
-  TestMethods.prototype.getSocket = () => {
-    return _socket;
-  };
-
-  this.__tests = new TestMethods();
+  get __tests() {
+    return new TestMethods(this.info.collation, this.socket);
+  }
 
   //*****************************************************************
   // internal methods
   //*****************************************************************
 
-  this._status = () => {
-    return _status;
-  };
-
   /**
-   * Execute query using text protocol with callback emit columns/data/end/error
-   * events to permit streaming big result-set
+   * Determine if the bulk protocol can be used for batch operations
    *
-   * @param sql     sql parameter Object can be used to supersede default option.
-   *                Object must then have sql property.
-   * @param values  object / array of placeholder values (not mandatory)
-   * @param cb      callback
-   * @returns {Query} query
+   * @param {Array} values - Batch values array
+   * @param {Object} options - Batch options
+   * @return {boolean} Whether bulk protocol can be used
+   * @private
    */
-  this._queryCallback = (sql, values, cb) => {
-    let _cmdOpts,
-      _sql,
-      _values = values,
-      _cb = cb;
+  _canUseBulk(values, options) {
+    // 1. Check compatibility with fullResult option
+    if (options && options.fullResult && (this.info.clientCapabilities & Capabilities.BULK_UNIT_RESULTS) === 0n) {
+      return false;
+    }
 
-    if (typeof values === 'function') {
-      _cb = values;
-      _values = undefined;
+    // 2. Determine if bulk operations are enabled
+    const bulkEnable =
+      options === undefined || options === null
+        ? this.opts.bulk
+        : options.bulk !== undefined && options.bulk !== null
+          ? options.bulk
+          : this.opts.bulk;
+
+    // 3. Check if server supports bulk operations
+    const serverSupportsBulk =
+      this.info.serverVersion &&
+      this.info.serverVersion.mariaDb &&
+      this.info.hasMinVersion(10, 2, 7) &&
+      (this.info.serverCapabilities & Capabilities.MARIADB_CLIENT_STMT_BULK_OPERATIONS) > 0n;
+
+    // If server doesn't support bulk or it's disabled, return false
+    if (!serverSupportsBulk || !bulkEnable) {
+      return false;
     }
 
-    if (typeof sql === 'object') {
-      _cmdOpts = sql;
-      _sql = _cmdOpts.sql;
-      if (sql.values) _values = sql.values;
-    } else {
-      _sql = sql;
+    // 4. No need to validate values if none provided
+    if (values === undefined) {
+      return true;
     }
 
-    let cmd;
-    if (_cb) {
-      const resolve = (rows) => {
-        const meta = rows.meta;
-        delete rows.meta;
-        _cb(null, rows, meta);
-      };
-      cmd = new Query(resolve, _cb, _cmdOpts, opts, _sql, _values);
+    // 5. Validate values based on placeholder type
+    if (!this.opts.namedPlaceholders) {
+      // For positional parameters
+      return this._validatePositionalParameters(values);
     } else {
-      cmd = new Query(
-        () => {},
-        () => {},
-        _cmdOpts,
-        opts,
-        _sql,
-        _values
-      );
+      // For named parameters
+      return this._validateNamedParameters(values);
     }
-    cmd.handleNewRows = (row) => {
-      cmd._rows[cmd._responseIndex].push(row);
-      cmd.emit('data', row);
-    };
-
-    if (opts.trace) Error.captureStackTrace(cmd);
-    _addCommand(cmd);
-    return cmd;
-  };
+  }
 
   /**
-   * Execute a batch using text protocol with callback emit columns/data/end/error
-   * events to permit streaming big result-set
+   * Validate batch values for positional parameters
    *
-   * @param sql     sql parameter Object can be used to supersede default option.
-   *                Object must then have sql property.
-   * @param values  object / array of placeholder values (not mandatory)
-   * @param cb      callback
-   * @returns {Query} query
+   * @param {Array} values - Batch values array
+   * @return {boolean} Whether values are valid for bulk protocol
+   * @private
    */
-  this._batchCallback = (sql, values, cb) => {
-    let _cmdOpts,
-      _sql,
-      _values = values,
-      _cb = cb;
-
-    if (typeof values === 'function') {
-      _cb = values;
-      _values = undefined;
-    }
+  _validatePositionalParameters(values) {
+    // Determine expected parameter length
+    const paramLen = Array.isArray(values[0]) ? values[0].length : values[0] ? 1 : 0;
 
-    if (typeof sql === 'object') {
-      _cmdOpts = sql;
-      _sql = _cmdOpts.sql;
-      if (sql.values) _values = sql.values;
-    } else {
-      _sql = sql;
-    }
-
-    if (_values !== undefined) {
-      _values = Array.isArray(_values) ? _values : [_values];
+    // If no parameters, can't use bulk
+    if (paramLen === 0) {
+      return false;
     }
 
-    let cmd;
+    // Check parameter consistency and streaming
+    for (const row of values) {
+      const rowArray = Array.isArray(row) ? row : [row];
 
-    if (!_values) {
-      if (_cb) {
-        _cb(
-          Errors.createError(
-            'Batch must have values set',
-            _sql,
-            false,
-            info,
-            'HY000',
-            Errors.ER_BATCH_WITH_NO_VALUES
-          )
-        );
+      // All parameter sets must have same length
+      if (paramLen !== rowArray.length) {
+        return false;
       }
-      return null;
-    }
-
-    let useBulk = canUseBulk(_values);
 
-    const fct = useBulk ? BatchBulk : BatchRewrite;
-
-    if (_cb) {
-      const resolve = (rows) => {
-        const meta = rows.meta;
-        delete rows.meta;
-        _cb(null, rows, meta);
-      };
-      cmd = new fct(resolve, _cb, _cmdOpts, opts, _sql, _values);
-    } else {
-      cmd = new fct(
-        () => {},
-        () => {},
-        _cmdOpts,
-        opts,
-        _sql,
-        _values
-      );
+      // Check for streaming data (not permitted)
+      for (const val of rowArray) {
+        if (this._isStreamingValue(val)) {
+          return false;
+        }
+      }
     }
-    cmd.handleNewRows = (row) => {
-      cmd._rows[cmd._responseIndex].push(row);
-      cmd.emit('data', row);
-    };
 
-    if (opts.trace) Error.captureStackTrace(cmd);
-    _addCommand(cmd);
-    return cmd;
-  };
+    return true;
+  }
 
   /**
-   * Use Batch rewrite or MariaDB bulk protocol.
+   * Validate batch values for named parameters
    *
-   * @param values current batch values
-   * @return {boolean} indicating if must use rewrite or bulk
+   * @param {Array} values - Batch values array
+   * @return {boolean} Whether values are valid for bulk protocol
+   * @private
    */
-  const canUseBulk = (values) => {
-    // not using info.isMariaDB() directly in case of callback use,
-    // without connection beeing completly finished.
-    let useBulk =
-      info.serverVersion &&
-      info.serverVersion.mariaDb &&
-      info.hasMinVersion(10, 2, 7) &&
-      opts.bulk &&
-      (info.serverCapabilities & Capabilities.MARIADB_CLIENT_STMT_BULK_OPERATIONS) > BigInt(0);
-
-    if (useBulk) {
-      //ensure that there is no stream object
-      if (values !== undefined) {
-        if (!opts.namedPlaceholders) {
-          //ensure that all parameters have same length
-          //single array is considered as an array of single element.
-          const paramLen = Array.isArray(values[0]) ? values[0].length : values[0] ? 1 : 0;
-          if (paramLen == 0) return false;
-          for (let r = 0; r < values.length; r++) {
-            let row = values[r];
-            if (!Array.isArray(row)) row = [row];
-            if (paramLen !== row.length) {
-              return false;
-            }
-            for (let j = 0; j < paramLen; j++) {
-              const val = row[j];
-              if (
-                val !== null &&
-                typeof val === 'object' &&
-                typeof val.pipe === 'function' &&
-                typeof val.read === 'function'
-              ) {
-                return false;
-              }
-            }
-          }
-        } else {
-          for (let r = 0; r < values.length; r++) {
-            let row = values[r];
-            const keys = Object.keys(row);
-            for (let j = 0; j < keys.length; j++) {
-              const val = row[keys[j]];
-              if (
-                val !== null &&
-                typeof val === 'object' &&
-                typeof val.pipe === 'function' &&
-                typeof val.read === 'function'
-              ) {
-                return false;
-              }
-            }
-          }
+  _validateNamedParameters(values) {
+    // Check each row for streaming values
+    for (const row of values) {
+      for (const val of Object.values(row)) {
+        if (this._isStreamingValue(val)) {
+          return false;
         }
       }
     }
-    return useBulk;
-  };
+    return true;
+  }
 
   /**
-   * Add handshake command to queue.
+   * Check if a value is a streaming value
    *
+   * @param {*} val - Value to check
+   * @return {boolean} Whether value is a streaming value
    * @private
    */
-  const _registerHandshakeCmd = (resolve, rejected) => {
-    const _authFail = _authFailHandler.bind(this, rejected);
-    const _authSucceed = _authSucceedHandler.bind(this, resolve, _authFail);
-
-    const handshake = new Handshake(
-      _authSucceed,
-      _authFail,
-      _createSecureContext.bind(this, _authFail),
-      _addCommandEnable.bind(this),
-      _getSocket
-    );
-    Error.captureStackTrace(handshake);
-
-    handshake.once('end', () => {
-      process.nextTick(_nextSendCmd);
-    });
-
-    _receiveQueue.push(handshake);
-    _initSocket(_authFail);
-  };
+  _isStreamingValue(val) {
+    return val != null && typeof val === 'object' && typeof val.pipe === 'function' && typeof val.read === 'function';
+  }
 
-  const _executeSessionVariableQuery = () => {
-    if (opts.sessionVariables) {
+  executeSessionVariableQuery() {
+    if (this.opts.sessionVariables) {
       const values = [];
       let sessionQuery = 'set ';
-      let keys = Object.keys(opts.sessionVariables);
+      let keys = Object.keys(this.opts.sessionVariables);
       if (keys.length > 0) {
-        return new Promise(function (resolve, reject) {
-          for (let k = 0; k < keys.length; ++k) {
-            sessionQuery +=
-              (k !== 0 ? ',' : '') + '@@' + keys[k].replace(/[^a-z0-9_]/gi, '') + '=?';
-            values.push(opts.sessionVariables[keys[k]]);
-          }
-          const errorHandling = (initialErr) => {
-            reject(
-              Errors.createError(
-                'Error setting session variable (value ' +
-                  JSON.stringify(opts.sessionVariables) +
-                  '). Error: ' +
-                  initialErr.message,
-                sessionQuery,
-                true,
-                info,
-                '08S01',
-                Errors.ER_SETTING_SESSION_ERROR,
-                null
-              )
-            );
-          };
-          const cmd = new Query(resolve, errorHandling, null, opts, sessionQuery, values);
-          if (opts.trace) Error.captureStackTrace(cmd);
-          _addCommand(cmd);
+        for (let k = 0; k < keys.length; ++k) {
+          sessionQuery += (k !== 0 ? ',' : '') + '@@' + keys[k].replace(/[^a-z0-9_]/gi, '') + '=?';
+          values.push(this.opts.sessionVariables[keys[k]]);
+        }
+
+        return new Promise(
+          this.query.bind(this, {
+            sql: sessionQuery,
+            values: values
+          })
+        ).catch((initialErr) => {
+          const err = Errors.createFatalError(
+            `Error setting session variable (value ${JSON.stringify(this.opts.sessionVariables)}). Error: ${
+              initialErr.message
+            }`,
+            Errors.ER_SETTING_SESSION_ERROR,
+            this.info,
+            '08S01',
+            sessionQuery
+          );
+          if (this.opts.logger.error) this.opts.logger.error(err);
+          return Promise.reject(err);
         });
       }
     }
     return Promise.resolve();
-  };
+  }
+
+  /**
+   * set charset to charset/collation if set or utf8mb4 if not.
+   * @returns {Promise<void>}
+   * @private
+   */
+  handleCharset() {
+    if (this.opts.collation) {
+      // if index <= 255, skip command, since collation has already been set during handshake response.
+      if (this.opts.collation.index <= 255) return Promise.resolve();
+      const charset =
+        this.opts.collation.charset === 'utf8' && this.opts.collation.maxLength === 4
+          ? 'utf8mb4'
+          : this.opts.collation.charset;
+      return new Promise(
+        this.query.bind(this, {
+          sql: `SET NAMES ${charset} COLLATE ${this.opts.collation.name}`
+        })
+      );
+    }
+
+    // MXS-4635: server can some information directly on first Ok_Packet, like not truncated collation
+    // in this case, avoid useless SET NAMES utf8mb4 command
+    if (
+      !this.opts.charset &&
+      this.info.collation &&
+      this.info.collation.charset === 'utf8' &&
+      this.info.collation.maxLength === 4
+    ) {
+      this.info.collation = Collations.fromCharset('utf8mb4');
+      return Promise.resolve();
+    }
+    const connCharset = this.opts.charset ? this.opts.charset : 'utf8mb4';
+    this.info.collation = Collations.fromCharset(connCharset);
+    return new Promise(
+      this.query.bind(this, {
+        sql: `SET NAMES ${connCharset}`
+      })
+    );
+  }
 
   /**
    * Asking server timezone if not set in case of 'auto'
    * @returns {Promise<void>}
    * @private
    */
-  const _checkServerTimezone = () => {
-    if (opts.timezone === 'auto') {
-      return this._queryPromise('SELECT @@system_time_zone stz, @@time_zone tz').then((res) => {
+  handleTimezone() {
+    const conn = this;
+    if (this.opts.timezone === 'local') this.opts.timezone = undefined;
+    if (this.opts.timezone === 'auto') {
+      return new Promise(
+        this.query.bind(this, {
+          sql: 'SELECT @@system_time_zone stz, @@time_zone tz'
+        })
+      ).then((res) => {
         const serverTimezone = res[0].tz === 'SYSTEM' ? res[0].stz : res[0].tz;
-        const serverZone = moment.tz.zone(serverTimezone);
-        if (serverZone) {
-          const localTz = moment.tz.guess();
-          if (serverTimezone === localTz) {
-            //db server and client use same timezone, avoid any conversion
-            opts.tz = null;
-          } else {
-            opts._localTz = localTz;
-            opts.tz = serverTimezone;
-          }
-        } else {
-          return Promise.reject(
-            Errors.createError(
-              "Automatic timezone setting fails. Server timezone '" +
-                serverTimezone +
-                "' does't have a corresponding IANA timezone. Option timezone must be set according to server timezone",
-              null,
-              true,
-              info,
-              '08S01',
-              Errors.ER_WRONG_AUTO_TIMEZONE
-            )
-          );
+        const localTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        if (serverTimezone === localTz || convertFixedTime(serverTimezone, conn) === convertFixedTime(localTz, conn)) {
+          //server timezone is identical to client tz, skipping setting
+          this.opts.timezone = localTz;
+          return Promise.resolve();
         }
-        return Promise.resolve();
+        return this._setSessionTimezone(convertFixedTime(localTz, conn));
       });
     }
-    if (opts.tz && !opts.skipSetTimezone) {
-      let tz = opts.tz;
-      if (opts.tz === 'Etc/UTC') {
-        tz = '+00:00';
-      } else if (opts.tz.startsWith('Etc/GMT')) {
-        let zone = moment.tz.zone(opts.tz);
-        tz = zone.abbrs[0] + ':00';
-      }
 
-      return this._queryPromise('SET time_zone=?', tz)
-        .then((res) => {
-          return Promise.resolve();
-        })
-        .catch((err) => {
-          console.log(
-            `warning: setting timezone '${opts.tz}' fails on server.\n look at https://mariadb.com/kb/en/mysql_tzinfo_to_sql/ to load IANA timezone.\nSetting timezone can be disabled with option \`skipSetTimezone\``
-          );
-          return Promise.resolve();
-        });
+    if (this.opts.timezone) {
+      return this._setSessionTimezone(convertFixedTime(this.opts.timezone, conn));
     }
     return Promise.resolve();
-  };
+  }
+
+  _setSessionTimezone(tz) {
+    return new Promise(
+      this.query.bind(this, {
+        sql: 'SET time_zone=?',
+        values: [tz]
+      })
+    ).catch((err) => {
+      const er = Errors.createFatalError(
+        `setting timezone '${tz}' fails on server.\n look at https://mariadb.com/kb/en/mysql_tzinfo_to_sql/ to load IANA timezone. `,
+        Errors.ER_WRONG_IANA_TIMEZONE,
+        this.info
+      );
+      if (this.opts.logger.error) this.opts.logger.error(er);
+      return Promise.reject(er);
+    });
+  }
 
-  const _checkServerVersion = () => {
-    if (!opts.forceVersionCheck) {
+  checkServerVersion() {
+    if (!this.opts.forceVersionCheck) {
       return Promise.resolve();
     }
-    return this._queryPromise('SELECT @@VERSION AS v').then((res) => {
-      info.serverVersion.raw = res[0].v;
-      info.serverVersion.mariaDb = info.serverVersion.raw.includes('MariaDB');
-      ConnectionInformation.parseVersionString(info);
-      return Promise.resolve();
-    });
-  };
+    return new Promise(
+      this.query.bind(this, {
+        sql: 'SELECT @@VERSION AS v'
+      })
+    ).then(
+      function (res) {
+        this.info.serverVersion.raw = res[0].v;
+        this.info.serverVersion.mariaDb = this.info.serverVersion.raw.includes('MariaDB');
+        ConnectionInformation.parseVersionString(this.info);
+        return Promise.resolve();
+      }.bind(this)
+    );
+  }
 
-  const _executeInitQuery = () => {
-    if (opts.initSql) {
-      const initialArr = Array.isArray(opts.initSql) ? opts.initSql : [opts.initSql];
+  executeInitQuery() {
+    if (this.opts.initSql) {
+      const initialArr = Array.isArray(this.opts.initSql) ? this.opts.initSql : [this.opts.initSql];
       const initialPromises = [];
       initialArr.forEach((sql) => {
-        initialPromises.push(this._queryPromise(sql));
+        initialPromises.push(
+          new Promise(
+            this.query.bind(this, {
+              sql: sql
+            })
+          )
+        );
       });
 
       return Promise.all(initialPromises).catch((initialErr) => {
-        return Promise.reject(
-          Errors.createError(
-            'Error executing initial sql command: ' + initialErr.message,
-            null,
-            true,
-            info,
-            '08S01',
-            Errors.ER_INITIAL_SQL_ERROR,
-            null
-          )
+        const err = Errors.createFatalError(
+          `Error executing initial sql command: ${initialErr.message}`,
+          Errors.ER_INITIAL_SQL_ERROR,
+          this.info
         );
+        if (this.opts.logger.error) this.opts.logger.error(err);
+        return Promise.reject(err);
       });
     }
     return Promise.resolve();
-  };
-
-  const _executeSessionTimeout = () => {
-    if (opts.queryTimeout) {
-      if (info.isMariaDB() && info.hasMinVersion(10, 1, 2)) {
-        const query = 'SET max_statement_time=' + opts.queryTimeout / 1000;
-        this._queryPromise(query).catch((initialErr) => {
-          return Promise.reject(
-            Errors.createError(
-              'Error setting session queryTimeout: ' + initialErr.message,
-              query,
-              true,
-              info,
-              '08S01',
+  }
+
+  executeSessionTimeout() {
+    if (this.opts.queryTimeout) {
+      if (this.info.isMariaDB() && this.info.hasMinVersion(10, 1, 2)) {
+        const query = `SET max_statement_time=${this.opts.queryTimeout / 1000}`;
+        new Promise(
+          this.query.bind(this, {
+            sql: query
+          })
+        ).catch(
+          function (initialErr) {
+            const err = Errors.createFatalError(
+              `Error setting session queryTimeout: ${initialErr.message}`,
               Errors.ER_INITIAL_TIMEOUT_ERROR,
-              null
-            )
-          );
-        });
+              this.info,
+              '08S01',
+              query
+            );
+            if (this.opts.logger.error) this.opts.logger.error(err);
+            return Promise.reject(err);
+          }.bind(this)
+        );
       } else {
-        return Promise.reject(
-          Errors.createError(
-            'Can only use queryTimeout for MariaDB server after 10.1.1. queryTimeout value: ' +
-              null,
-            opts.queryTimeout,
-            false,
-            info,
-            'HY000',
-            Errors.ER_TIMEOUT_NOT_SUPPORTED
-          )
+        const err = Errors.createError(
+          `Can only use queryTimeout for MariaDB server after 10.1.1. queryTimeout value: ${this.opts.queryTimeout}`,
+          Errors.ER_TIMEOUT_NOT_SUPPORTED,
+          this.info,
+          'HY000',
+          this.opts.queryTimeout
         );
+        if (this.opts.logger.error) this.opts.logger.error(err);
+        return Promise.reject(err);
       }
     }
     return Promise.resolve();
-  };
+  }
 
-  const _getSocket = () => {
-    return _socket;
-  };
+  getSocket() {
+    return this.socket;
+  }
 
   /**
    * Initialize socket and associate events.
    * @private
    */
-  const _initSocket = (authFailHandler) => {
-    if (opts.socketPath) {
-      _socket = Net.connect(opts.socketPath);
-    } else {
-      _socket = Net.connect(opts.port, opts.host);
+  streamInitSocket() {
+    if (this.opts.connectTimeout) {
+      this.timeout = setTimeout(this.connectTimeoutReached.bind(this), this.opts.connectTimeout, Date.now());
     }
-
-    if (opts.connectTimeout) {
-      _timeout = setTimeout(
-        _connectTimeoutReached,
-        opts.connectTimeout,
-        authFailHandler,
-        Date.now()
-      );
+    if (this.opts.socketPath) {
+      this.socket = Net.connect(this.opts.socketPath);
+    } else if (this.opts.stream) {
+      if (typeof this.opts.stream === 'function') {
+        const tmpSocket = this.opts.stream(
+          function (err, stream) {
+            if (err) {
+              this.authFailHandler(err);
+              return;
+            }
+            this.socket = stream ? stream : Net.connect(this.opts.port, this.opts.host);
+            this.socketInit();
+          }.bind(this)
+        );
+        if (tmpSocket) {
+          this.socket = tmpSocket;
+          this.socketInit();
+        }
+      } else {
+        this.authFailHandler(
+          Errors.createError(
+            'stream option is not a function. stream must be a function with (error, callback) parameter',
+            Errors.ER_BAD_PARAMETER_VALUE,
+            this.info
+          )
+        );
+      }
+      return;
+    } else {
+      this.socket = Net.connect(this.opts.port, this.opts.host);
+      this.socket.setNoDelay(true);
     }
+    this.socketInit();
+  }
 
-    const _socketError = _socketErrorHandler.bind(this, authFailHandler);
+  socketInit() {
+    this.socket.on('data', this.streamIn.onData.bind(this.streamIn));
+    this.socket.on('error', this.socketErrorHandler.bind(this));
+    this.socket.on('end', this.socketErrorHandler.bind(this));
 
-    _socket.on('data', _in.onData.bind(_in));
-    _socket.on('error', _socketError);
-    _socket.on('end', _socketError);
-    _socket.on(
+    this.socket.on(
       'connect',
       function () {
-        clearTimeout(_timeout);
-        if (_status === Status.CONNECTING) {
-          _status = Status.AUTHENTICATING;
-          _socketConnected = true;
-          _socket.setTimeout(opts.socketTimeout, _socketTimeoutReached.bind(this, authFailHandler));
-          _socket.setNoDelay(true);
-
+        if (this.status === Status.CONNECTING) {
+          this.status = Status.AUTHENTICATING;
+          this.socket.setNoDelay(true);
+          this.socket.setTimeout(this.opts.socketTimeout, this.socketTimeoutReached.bind(this));
           // keep alive for socket. This won't reset server wait_timeout use pool option idleTimeout for that
-          if (opts.keepAliveDelay) {
-            _socket.setKeepAlive(true, opts.keepAliveDelay);
+          if (this.opts.keepAliveDelay >= 0) {
+            this.socket.setKeepAlive(true, this.opts.keepAliveDelay);
+          } else {
+            this.socket.setKeepAlive(true);
           }
         }
       }.bind(this)
     );
 
-    _socket.writeBuf = (buf) => _socket.write(buf);
-    _socket.flush = () => {};
-    _out.setStream(_socket);
-  };
+    this.socket.writeBuf = (buf) => this.socket.write(buf);
+    this.socket.flush = () => {};
+    this.streamOut.setStream(this.socket);
+  }
 
   /**
    * Authentication success result handler.
    *
    * @private
    */
-  const _authSucceedHandler = (resolve, rejected) => {
+  authSucceedHandler() {
     //enable packet compression according to option
-    if (opts.logPackets) info.enableLogPacket();
-    if (opts.compress) {
-      if (info.serverCapabilities & Capabilities.COMPRESS) {
-        _out.setStream(new CompressionOutputStream(_socket, opts, info));
-        _in = new CompressionInputStream(_in, _receiveQueue, opts, info);
-        _socket.removeAllListeners('data');
-        _socket.on('data', _in.onData.bind(_in));
-      } else {
-        console.error(
-          "connection is configured to use packet compression, but the server doesn't have this capability"
+    if (this.opts.compress) {
+      if (this.info.serverCapabilities & Capabilities.COMPRESS) {
+        this.streamOut.setStream(new CompressionOutputStream(this.socket, this.opts, this.info));
+        this.streamIn = new CompressionInputStream(this.streamIn, this.receiveQueue, this.opts, this.info);
+        this.socket.removeAllListeners('data');
+        this.socket.on('data', this.streamIn.onData.bind(this.streamIn));
+      } else if (this.opts.logger.error) {
+        this.opts.logger.error(
+          Errors.createError(
+            "connection is configured to use packet compression, but the server doesn't have this capability",
+            Errors.ER_COMPRESSION_NOT_SUPPORTED,
+            this.info
+          )
         );
       }
     }
 
-    _addCommand = opts.pipelining ? _addCommandEnablePipeline : _addCommandEnable;
+    this.addCommand = this.opts.pipelining ? this.addCommandEnablePipeline : this.addCommandEnable;
+    const conn = this;
+    this.status = Status.INIT_CMD;
+    this.executeSessionVariableQuery()
+      .then(conn.handleCharset.bind(conn))
+      .then(this.handleTimezone.bind(this))
+      .then(this.checkServerVersion.bind(this))
+      .then(this.executeInitQuery.bind(this))
+      .then(this.executeSessionTimeout.bind(this))
+      .then(() => {
+        clearTimeout(this.timeout);
+        conn.status = Status.CONNECTED;
+        process.nextTick(conn.connectResolveFct, conn);
 
-    const commands = _waitingAuthenticationQueue.toArray();
-    commands.forEach((cmd) => {
-      _addCommand(cmd);
-    });
+        const commands = conn.waitingAuthenticationQueue.toArray();
+        commands.forEach((cmd) => {
+          conn.addCommand(cmd, true);
+        });
+        conn.waitingAuthenticationQueue = null;
 
-    const errorInitialQueries = (err) => {
-      if (!err.fatal) this.end().catch((err) => {});
-      process.nextTick(rejected, err);
-    };
-    _status = Status.INIT_CMD;
-    _executeSessionVariableQuery()
-      .then(() => {
-        return _checkServerTimezone();
+        conn.connectRejectFct = null;
+        conn.connectResolveFct = null;
       })
-      .then(() => {
-        return _checkServerVersion();
-      })
-      .then(() => {
-        return _executeInitQuery();
-      })
-      .then(() => {
-        return _executeSessionTimeout();
-      })
-      .then(() => {
-        _status = Status.CONNECTED;
-        process.nextTick(resolve, this);
-      })
-      .catch(errorInitialQueries);
-  };
+      .catch((err) => {
+        if (!err.fatal) {
+          const res = () => {
+            conn.authFailHandler.call(conn, err);
+          };
+          conn.end(res, res);
+        } else {
+          conn.authFailHandler.call(conn, err);
+        }
+        return Promise.reject(err);
+      });
+  }
 
   /**
    * Authentication failed result handler.
    *
    * @private
    */
-  const _authFailHandler = (reject, err) => {
-    process.nextTick(reject, err);
-    //remove handshake command
-    _receiveQueue.shift();
-
-    _fatalError(err, true);
-  };
+  authFailHandler(err) {
+    clearTimeout(this.timeout);
+    if (this.connectRejectFct) {
+      if (this.opts.logger.error) this.opts.logger.error(err);
+      //remove handshake command
+      this.receiveQueue.shift();
+      this.fatalError(err, true);
+
+      process.nextTick(this.connectRejectFct, err);
+      this.connectRejectFct = null;
+    }
+  }
 
   /**
    * Create TLS socket and associate events.
    *
-   * @param rejected  rejected function when error
+   * @param info current connection information
    * @param callback  callback function when done
    * @private
    */
-  const _createSecureContext = (rejected, callback) => {
-    const _socketError = _socketErrorHandler.bind(this, rejected);
-    const sslOption = Object.assign({}, opts.ssl, {
-      servername: opts.host,
-      socket: _socket
-    });
+  createSecureContext(info, callback) {
+    info.requireValidCert =
+      this.opts.ssl === true ||
+      this.opts.ssl.rejectUnauthorized === undefined ||
+      this.opts.ssl.rejectUnauthorized === true;
+
+    const baseConf = { socket: this.socket };
+    if (info.isMariaDB()) {
+      // for MariaDB servers, permit self-signed certificated
+      // this will be replaced by fingerprint validation with ending OK_PACKET
+      baseConf['rejectUnauthorized'] = false;
+    }
+    const sslOption = this.opts.ssl === true ? baseConf : Object.assign({}, this.opts.ssl, baseConf);
 
     try {
       const secureSocket = tls.connect(sslOption, callback);
-
-      secureSocket.on('data', _in.onData.bind(_in));
-      secureSocket.on('error', _socketError);
-      secureSocket.on('end', _socketError);
+      secureSocket.on('data', this.streamIn.onData.bind(this.streamIn));
+      secureSocket.on('error', this.socketErrorHandler.bind(this));
+      secureSocket.on('end', this.socketErrorHandler.bind(this));
       secureSocket.writeBuf = (buf) => secureSocket.write(buf);
       secureSocket.flush = () => {};
 
-      _socket.removeAllListeners('data');
-      _socket = secureSocket;
+      this.socket.removeAllListeners('data');
+      this.socket = secureSocket;
 
-      _out.setStream(secureSocket);
+      this.streamOut.setStream(secureSocket);
     } catch (err) {
-      _socketError(err);
+      this.socketErrorHandler(err);
     }
-  };
+  }
 
   /**
    * Handle packet when no packet is expected.
@@ -1076,184 +1372,116 @@ function Connection(options) {
    * @param packet  packet
    * @private
    */
-  const _unexpectedPacket = function (packet) {
+  unexpectedPacket(packet) {
     if (packet && packet.peek() === 0xff) {
       //can receive unexpected error packet from server/proxy
       //to inform that connection is closed (usually by timeout)
-      let err = packet.readError(info);
-      if (err.fatal && _status !== Status.CLOSING && _status !== Status.CLOSED) {
+      let err = packet.readError(this.info);
+      if (err.fatal && this.status < Status.CLOSING) {
         this.emit('error', err);
-        this.end();
+        if (this.opts.logger.error) this.opts.logger.error(err);
+        this.end(
+          () => {},
+          () => {}
+        );
       }
-    } else if (_status !== Status.CLOSING && _status !== Status.CLOSED) {
-      this.emit(
-        'error',
-        Errors.createError(
-          'receiving packet from server without active commands\n' +
-            'conn:' +
-            (info.threadId ? info.threadId : -1) +
-            '(' +
-            packet.pos +
-            ',' +
-            packet.end +
-            ')\n' +
-            Utils.log(opts, packet.buf, packet.pos, packet.end),
-          null,
-          true,
-          info,
-          '08S01',
-          Errors.ER_UNEXPECTED_PACKET
-        )
+    } else if (this.status < Status.CLOSING) {
+      const err = Errors.createFatalError(
+        `receiving packet from server without active commands\nconn:${this.info.threadId ? this.info.threadId : -1}(${
+          packet.pos
+        },${packet.end})\n${Utils.log(this.opts, packet.buf, packet.pos, packet.end)}`,
+        Errors.ER_UNEXPECTED_PACKET,
+        this.info
       );
+      if (this.opts.logger.error) this.opts.logger.error(err);
+      this.emit('error', err);
       this.destroy();
     }
-  };
-
-  /**
-   * Change transaction state.
-   *
-   * @param sql sql
-   * @returns {Promise} promise
-   * @private
-   */
-  const _changeTransaction = (sql) => {
-    //if command in progress, driver cannot rely on status and must execute query
-    if (_status === Status.CLOSING || _status === Status.CLOSED) {
-      return Promise.reject(
-        Errors.createError(
-          'Cannot execute new commands: connection closed',
-          sql,
-          true,
-          info,
-          '08S01',
-          Errors.ER_CMD_CONNECTION_CLOSED
-        )
-      );
-    }
-
-    //Command in progress => must execute query
-    //or if no command in progress, can rely on status to know if query is needed
-    if (_receiveQueue.peekFront() || info.status & ServerStatus.STATUS_IN_TRANS) {
-      return new Promise(function (resolve, reject) {
-        const cmd = new Query(resolve, reject, null, opts, sql, null);
-        if (opts.trace) Error.captureStackTrace(cmd);
-        _addCommand(cmd);
-      });
-    }
-    return Promise.resolve();
-  };
+  }
 
   /**
    * Handle connection timeout.
    *
    * @private
    */
-  const _connectTimeoutReached = function (authFailHandler, initialConnectionTime) {
-    _timeout = null;
-    const handshake = _receiveQueue.peekFront();
-    authFailHandler(
-      Errors.createError(
-        'Connection timeout: failed to create socket after ' +
-          (Date.now() - initialConnectionTime) +
-          'ms',
-        null,
-        true,
-        info,
-        '08S01',
-        Errors.ER_CONNECTION_TIMEOUT,
-        handshake ? handshake.stack : null
-      )
+  connectTimeoutReached(initialConnectionTime) {
+    this.timeout = null;
+    const handshake = this.receiveQueue.peekFront();
+    const err = Errors.createFatalError(
+      `Connection timeout: failed to create socket after ${Date.now() - initialConnectionTime}ms`,
+      Errors.ER_CONNECTION_TIMEOUT,
+      this.info,
+      '08S01',
+      null,
+      handshake ? handshake.stack : null
     );
-  };
+    if (this.opts.logger.error) this.opts.logger.error(err);
+    this.authFailHandler(err);
+  }
 
   /**
    * Handle socket timeout.
    *
    * @private
    */
-  const _socketTimeoutReached = function () {
-    const err = Errors.createError(
-      'socket timeout',
-      null,
-      true,
-      info,
-      '08S01',
-      Errors.ER_SOCKET_TIMEOUT
-    );
-    const packetMsgs = info.getLastPackets();
-    if (packetMsgs !== '') {
-      err.message = err.message + '\nlast received packets:\n' + packetMsgs;
-    }
-    _fatalError(err, true);
-  };
+  socketTimeoutReached() {
+    clearTimeout(this.timeout);
+    const err = Errors.createFatalError('socket timeout', Errors.ER_SOCKET_TIMEOUT, this.info);
+    if (this.opts.logger.error) this.opts.logger.error(err);
+    this.fatalError(err, true);
+  }
 
   /**
    * Add command to waiting queue until authentication.
    *
    * @param cmd         command
-   * @returns {*}       current command
    * @private
    */
-  const _addCommandQueue = (cmd) => {
-    _waitingAuthenticationQueue.push(cmd);
-    return cmd;
-  };
+  addCommandQueue(cmd) {
+    this.waitingAuthenticationQueue.push(cmd);
+  }
 
   /**
    * Add command to command sending and receiving queue.
    *
    * @param cmd         command
-   * @returns {*}       current command
+   * @param expectResponse queue command response
    * @private
    */
-  const _addCommandEnable = (cmd) => {
-    cmd.once('end', () => {
-      setImmediate(_nextSendCmd);
-    });
+  addCommandEnable(cmd, expectResponse) {
+    cmd.once('end', this._sendNextCmdImmediate.bind(this));
 
     //send immediately only if no current active receiver
-    if (_sendQueue.isEmpty() && (_status === Status.INIT_CMD || _status === Status.CONNECTED)) {
-      if (_receiveQueue.peekFront()) {
-        _receiveQueue.push(cmd);
-        _sendQueue.push(cmd);
-        return cmd;
-      }
-
-      _receiveQueue.push(cmd);
-      cmd.start(_out, opts, info);
+    if (this.sendQueue.isEmpty() && this.receiveQueue.isEmpty()) {
+      if (expectResponse) this.receiveQueue.push(cmd);
+      cmd.start(this.streamOut, this.opts, this.info);
     } else {
-      _receiveQueue.push(cmd);
-      _sendQueue.push(cmd);
+      if (expectResponse) this.receiveQueue.push(cmd);
+      this.sendQueue.push(cmd);
     }
-    return cmd;
-  };
+  }
 
   /**
    * Add command to command sending and receiving queue using pipelining
    *
-   * @param cmd         command
-   * @returns {*}       current command
+   * @param cmd             command
+   * @param expectResponse queue command response
    * @private
    */
-  const _addCommandEnablePipeline = (cmd) => {
-    cmd.once('send_end', () => {
-      setImmediate(_nextSendCmd);
-    });
+  addCommandEnablePipeline(cmd, expectResponse) {
+    cmd.once('send_end', this._sendNextCmdImmediate.bind(this));
 
-    _receiveQueue.push(cmd);
-    if (_sendQueue.isEmpty()) {
-      cmd.start(_out, opts, info);
+    if (expectResponse) this.receiveQueue.push(cmd);
+    if (this.sendQueue.isEmpty()) {
+      cmd.start(this.streamOut, this.opts, this.info);
       if (cmd.sending) {
-        _sendQueue.push(cmd);
-        cmd.prependOnceListener('send_end', () => {
-          _sendQueue.shift();
-        });
+        this.sendQueue.push(cmd);
+        cmd.prependOnceListener('send_end', this.sendQueue.shift.bind(this.sendQueue));
       }
     } else {
-      _sendQueue.push(cmd);
+      this.sendQueue.push(cmd);
     }
-    return cmd;
-  };
+  }
 
   /**
    * Replacing command when connection is closing or closed to send a proper error message.
@@ -1261,111 +1489,95 @@ function Connection(options) {
    * @param cmd         command
    * @private
    */
-  const _addCommandDisabled = (cmd) => {
-    cmd.throwNewError(
+  addCommandDisabled(cmd) {
+    const err = cmd.throwNewError(
       'Cannot execute new commands: connection closed',
       true,
-      info,
+      this.info,
       '08S01',
       Errors.ER_CMD_CONNECTION_CLOSED
     );
-  };
+    if (this.opts.logger.error) this.opts.logger.error(err);
+  }
 
   /**
    * Handle socket error.
    *
-   * @param authFailHandler   authentication handler
    * @param err               socket error
    * @private
    */
-  const _socketErrorHandler = function (authFailHandler, err) {
-    if (_status === Status.CLOSING || _status === Status.CLOSED) return;
-    if (_socket) {
-      _socket.writeBuf = () => {};
-      _socket.flush = () => {};
+  socketErrorHandler(err) {
+    if (this.status >= Status.CLOSING) return;
+    if (this.socket) {
+      this.socket.writeBuf = () => {};
+      this.socket.flush = () => {};
     }
 
     //socket has been ended without error
     if (!err) {
-      err = Errors.createError(
+      err = Errors.createFatalError(
         'socket has unexpectedly been closed',
-        null,
-        true,
-        info,
-        '08S01',
-        Errors.ER_SOCKET_UNEXPECTED_CLOSE
+        Errors.ER_SOCKET_UNEXPECTED_CLOSE,
+        this.info
       );
     } else {
       err.fatal = true;
-      this.sqlState = 'HY000';
+      err.sqlState = 'HY000';
     }
 
-    const packetMsgs = info.getLastPackets();
-    if (packetMsgs !== '') {
-      err.message += '\nlast received packets:\n' + packetMsgs;
-    }
-
-    switch (_status) {
+    switch (this.status) {
       case Status.CONNECTING:
       case Status.AUTHENTICATING:
-        const currentCmd = _receiveQueue.peekFront();
+        const currentCmd = this.receiveQueue.peekFront();
         if (currentCmd && currentCmd.stack && err) {
-          err.stack +=
-            '\n From event:\n' + currentCmd.stack.substring(currentCmd.stack.indexOf('\n') + 1);
+          err.stack += '\n From event:\n' + currentCmd.stack.substring(currentCmd.stack.indexOf('\n') + 1);
         }
-        authFailHandler(err);
+        this.authFailHandler(err);
         break;
 
       default:
-        _fatalError(err, false);
+        this.fatalError(err, false);
     }
-  };
+  }
 
   /**
    * Fatal unexpected error : closing connection, and throw exception.
-   *
-   * @param self    current connection
-   * @private
    */
-  const _fatalErrorHandler = function (self) {
-    return function (err, avoidThrowError) {
-      if (_status === Status.CLOSING || _status === Status.CLOSED) {
-        socketErrorDispatchToQueries(err);
-        return;
-      }
-      const mustThrowError = _status !== Status.CONNECTING;
-      _status = Status.CLOSING;
-
-      //prevent executing new commands
-      _addCommand = _addCommandDisabled;
-
-      if (_socket) {
-        _socket.removeAllListeners('error');
-        _socket.removeAllListeners('timeout');
-        _socket.removeAllListeners('close');
-        _socket.removeAllListeners('data');
-        if (!_socket.destroyed) _socket.destroy();
-        _socket = undefined;
-      }
-      _status = Status.CLOSED;
-
-      const errorThrownByCmd = socketErrorDispatchToQueries(err);
-      if (mustThrowError) {
-        if (self.listenerCount('error') > 0) {
-          self.emit('error', err);
-          self.emit('end');
-          _clear();
-        } else {
-          self.emit('end');
-          _clear();
-          //error will be thrown if no error listener and no command did throw the exception
-          if (!avoidThrowError && !errorThrownByCmd) throw err;
-        }
+  fatalError(err, avoidThrowError) {
+    if (this.status >= Status.CLOSING) {
+      this.socketErrorDispatchToQueries(err);
+      return;
+    }
+    const mustThrowError = this.status !== Status.CONNECTING;
+    this.status = Status.CLOSING;
+
+    //prevent executing new commands
+    this.addCommand = this.addCommandDisabled;
+
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      if (!this.socket.destroyed) this.socket.destroy();
+      this.socket = undefined;
+    }
+    this.status = Status.CLOSED;
+
+    const errorThrownByCmd = this.socketErrorDispatchToQueries(err);
+    if (mustThrowError) {
+      if (this.opts.logger.error) this.opts.logger.error(err);
+      if (this.listenerCount('error') > 0) {
+        this.emit('error', err);
+        this.emit('end');
+        this.clear();
       } else {
-        _clear();
+        this.emit('end');
+        this.clear();
+        //error will be thrown if no error listener and no command did throw the exception
+        if (!avoidThrowError && !errorThrownByCmd) throw err;
       }
-    };
-  };
+    } else {
+      this.clear();
+    }
+  }
 
   /**
    * Dispatch fatal error to current running queries.
@@ -1373,88 +1585,599 @@ function Connection(options) {
    * @param err        the fatal error
    * @return {boolean} return if error has been relayed to queries
    */
-  const socketErrorDispatchToQueries = (err) => {
+  socketErrorDispatchToQueries(err) {
     let receiveCmd;
     let errorThrownByCmd = false;
-    while ((receiveCmd = _receiveQueue.shift())) {
+    while ((receiveCmd = this.receiveQueue.shift())) {
       if (receiveCmd && receiveCmd.onPacketReceive) {
         errorThrownByCmd = true;
-        setImmediate(receiveCmd.throwError.bind(receiveCmd), err, info);
+        setImmediate(receiveCmd.throwError.bind(receiveCmd, err, this.info));
       }
     }
     return errorThrownByCmd;
-  };
+  }
 
   /**
    * Will send next command in queue if any.
    *
    * @private
    */
-  const _nextSendCmd = () => {
+  nextSendCmd() {
     let sendCmd;
-    if ((sendCmd = _sendQueue.shift())) {
+    if ((sendCmd = this.sendQueue.shift())) {
       if (sendCmd.sending) {
-        _sendQueue.unshift(sendCmd);
+        this.sendQueue.unshift(sendCmd);
       } else {
-        sendCmd.start(_out, opts, info);
+        sendCmd.start(this.streamOut, this.opts, this.info);
         if (sendCmd.sending) {
-          sendCmd.prependOnceListener('send_end', () => {
-            _sendQueue.shift();
-          });
-          _sendQueue.unshift(sendCmd);
+          this.sendQueue.unshift(sendCmd);
+          sendCmd.prependOnceListener('send_end', this.sendQueue.shift.bind(this.sendQueue));
         }
       }
     }
-  };
+  }
+
+  /**
+   * Change transaction state.
+   *
+   * @param cmdParam command parameter
+   * @param resolve success function to call
+   * @param reject error function to call
+   * @private
+   */
+  changeTransaction(cmdParam, resolve, reject) {
+    //if command in progress, driver cannot rely on status and must execute query
+    if (this.status >= Status.CLOSING) {
+      const err = Errors.createFatalError(
+        'Cannot execute new commands: connection closed',
+        Errors.ER_CMD_CONNECTION_CLOSED,
+        this.info,
+        '08S01',
+        cmdParam.sql
+      );
+      this._logAndReject(reject, err);
+      return;
+    }
+
+    //Command in progress => must execute query
+    //or if no command in progress, can rely on status to know if query is needed
+    if (this.receiveQueue.peekFront() || this.info.status & ServerStatus.STATUS_IN_TRANS) {
+      const cmd = new Query(resolve, (err) => this._logAndReject(reject, err), this.opts, cmdParam);
+      this.addCommand(cmd, true);
+    } else resolve();
+  }
+
+  changeUser(cmdParam, resolve, reject) {
+    if (!this.info.isMariaDB()) {
+      const err = Errors.createError(
+        'method changeUser not available for MySQL server due to Bug #83472',
+        Errors.ER_MYSQL_CHANGE_USER_BUG,
+        this.info,
+        '0A000'
+      );
+      this._logAndReject(reject, err);
+      return;
+    }
+    if (this.status < Status.CLOSING) {
+      this.addCommand = this.addCommandEnable;
+    }
+    let conn = this;
+    if (cmdParam.opts && cmdParam.opts.collation && typeof cmdParam.opts.collation === 'string') {
+      const val = cmdParam.opts.collation.toUpperCase();
+      cmdParam.opts.collation = Collations.fromName(cmdParam.opts.collation.toUpperCase());
+      if (cmdParam.opts.collation === undefined) return reject(new RangeError(`Unknown collation '${val}'`));
+    }
+
+    this.addCommand(
+      new ChangeUser(
+        cmdParam,
+        this.opts,
+        (res) => {
+          if (conn.status < Status.CLOSING && conn.opts.pipelining) conn.addCommand = conn.addCommandEnablePipeline;
+          if (cmdParam.opts && cmdParam.opts.collation) conn.opts.collation = cmdParam.opts.collation;
+          conn
+            .handleCharset()
+            .then(() => {
+              if (cmdParam.opts && cmdParam.opts.collation) {
+                conn.info.collation = cmdParam.opts.collation;
+                conn.opts.emit('collation', cmdParam.opts.collation);
+              }
+              resolve(res);
+            })
+            .catch((err) => {
+              const res = () => conn.authFailHandler.call(conn, err);
+              if (!err.fatal) {
+                conn.end(res, res);
+              } else {
+                res();
+              }
+              reject(err);
+            });
+        },
+        this.authFailHandler.bind(this, reject),
+        this.getSocket.bind(this)
+      ),
+      true
+    );
+  }
+
+  query(cmdParam, resolve, reject) {
+    if (!cmdParam.sql)
+      return reject(
+        Errors.createError(
+          'sql parameter is mandatory',
+          Errors.ER_UNDEFINED_SQL,
+          this.info,
+          'HY000',
+          null,
+          false,
+          cmdParam.stack
+        )
+      );
+    const cmd = new Query(resolve, (err) => this._logAndReject(reject, err), this.opts, cmdParam);
+    this.addCommand(cmd, true);
+  }
+
+  prepare(cmdParam, resolve, reject) {
+    if (!cmdParam.sql) {
+      reject(Errors.createError('sql parameter is mandatory', Errors.ER_UNDEFINED_SQL, this.info, 'HY000'));
+      return;
+    }
+    if (this.prepareCache && (this.sendQueue.isEmpty() || !this.receiveQueue.peekFront())) {
+      // no command in queue, database is then considered ok, and cache can be search right now
+      const cachedPrepare = this.prepareCache.get(cmdParam.sql);
+      if (cachedPrepare) {
+        resolve(cachedPrepare);
+        return;
+      }
+    }
+
+    const cmd = new Prepare(resolve, (err) => this._logAndReject(reject, err), this.opts, cmdParam, this);
+    this.addCommand(cmd, true);
+  }
+
+  prepareExecute(cmdParam, resolve, reject) {
+    if (!cmdParam.sql) {
+      reject(Errors.createError('sql parameter is mandatory', Errors.ER_UNDEFINED_SQL, this.info, 'HY000'));
+      return;
+    }
+
+    if (this.prepareCache && (this.sendQueue.isEmpty() || !this.receiveQueue.peekFront())) {
+      // no command in queue, current database is known, so cache can be search right now
+      const cachedPrepare = this.prepareCache.get(cmdParam.sql);
+      if (cachedPrepare) {
+        this.executePromise(
+          cmdParam,
+          cachedPrepare,
+          (res) => {
+            resolve(res);
+            cachedPrepare.close();
+          },
+          (err) => {
+            reject(err);
+            cachedPrepare.close();
+          }
+        );
+        return;
+      }
+    }
+
+    // permit pipelining PREPARE and EXECUTE if mariadb 10.2.4+ and has no streaming
+    const conn = this;
+    if (this.opts.pipelining && this.info.isMariaDB() && this.info.hasMinVersion(10, 2, 4)) {
+      let hasStreamingValue = false;
+      const vals = cmdParam.values ? (Array.isArray(cmdParam.values) ? cmdParam.values : [cmdParam.values]) : [];
+      for (let i = 0; i < vals.length; i++) {
+        const val = vals[i];
+        if (
+          val != null &&
+          typeof val === 'object' &&
+          typeof val.pipe === 'function' &&
+          typeof val.read === 'function'
+        ) {
+          hasStreamingValue = true;
+        }
+      }
+      if (!hasStreamingValue) {
+        let nbExecute = 0;
+        const executeCommand = new Execute(
+          (res) => {
+            if (nbExecute++ === 0) {
+              executeCommand.prepare.close();
+              resolve(res);
+            }
+          },
+          (err) => {
+            if (nbExecute++ === 0) {
+              if (conn.opts.logger.error) conn.opts.logger.error(err);
+              reject(err);
+              if (executeCommand.prepare) {
+                executeCommand.prepare.close();
+              }
+            }
+          },
+          conn.opts,
+          cmdParam,
+          null
+        );
+        cmdParam.executeCommand = executeCommand;
+        const cmd = new Prepare(
+          (prep) => {
+            if (nbExecute > 0) prep.close();
+          },
+          (err) => {
+            if (nbExecute++ === 0) {
+              if (conn.opts.logger.error) conn.opts.logger.error(err);
+              reject(err);
+            }
+          },
+          conn.opts,
+          cmdParam,
+          conn
+        );
+        conn.addCommand(cmd, true);
+        conn.addCommand(executeCommand, true);
+        return;
+      }
+    }
+
+    // execute PREPARE, then EXECUTE
+    const cmd = new Prepare(
+      (prepare) => {
+        conn.executePromise(
+          cmdParam,
+          prepare,
+          (res) => {
+            resolve(res);
+            prepare.close();
+          },
+          (err) => {
+            if (conn.opts.logger.error) conn.opts.logger.error(err);
+            reject(err);
+            prepare.close();
+          }
+        );
+      },
+      (err) => {
+        if (conn.opts.logger.error) conn.opts.logger.error(err);
+        reject(err);
+      },
+      this.opts,
+      cmdParam,
+      conn
+    );
+    conn.addCommand(cmd, true);
+  }
+
+  importFile(cmdParam, resolve, reject) {
+    const conn = this;
+    if (!cmdParam || !cmdParam.file) {
+      return reject(
+        Errors.createError(
+          'SQL file parameter is mandatory',
+          Errors.ER_MISSING_SQL_PARAMETER,
+          conn.info,
+          'HY000',
+          null,
+          false,
+          cmdParam.stack
+        )
+      );
+    }
+
+    const prevAddCommand = this.addCommand.bind(conn);
+
+    this.waitingAuthenticationQueue = new Queue();
+    this.addCommand = this.addCommandQueue;
+    const tmpQuery = function (sql, resolve, reject) {
+      const cmd = new Query(
+        resolve,
+        (err) => {
+          if (conn.opts.logger.error) conn.opts.logger.error(err);
+          reject(err);
+        },
+        conn.opts,
+        {
+          sql: sql,
+          opts: {}
+        }
+      );
+      prevAddCommand(cmd, true);
+    };
+
+    let prevDatabase = null;
+    return (
+      cmdParam.skipDbCheck ? Promise.resolve() : new Promise(tmpQuery.bind(conn, 'SELECT DATABASE() as db'))
+    ).then((res) => {
+      prevDatabase = res ? res[0].db : null;
+      if (
+        (cmdParam.skipDbCheck && !conn.opts.database) ||
+        (!cmdParam.skipDbCheck && !cmdParam.database && !prevDatabase)
+      ) {
+        return reject(
+          Errors.createError(
+            'Database parameter is not set and no database is selected',
+            Errors.ER_MISSING_DATABASE_PARAMETER,
+            conn.info,
+            'HY000',
+            null,
+            false,
+            cmdParam.stack
+          )
+        );
+      }
+      const searchDbPromise = cmdParam.database
+        ? new Promise(tmpQuery.bind(conn, `USE \`${cmdParam.database.replace(/`/gi, '``')}\``))
+        : Promise.resolve();
+      return searchDbPromise.then(() => {
+        const endingFunction = () => {
+          if (conn.status < Status.CLOSING) {
+            conn.addCommand = conn.addCommandEnable.bind(conn);
+            if (conn.status < Status.CLOSING && conn.opts.pipelining) {
+              conn.addCommand = conn.addCommandEnablePipeline.bind(conn);
+            }
+            const commands = conn.waitingAuthenticationQueue.toArray();
+            commands.forEach((cmd) => conn.addCommand(cmd, true));
+            conn.waitingAuthenticationQueue = null;
+          }
+        };
+        return fsPromises
+          .open(cmdParam.file, 'r')
+          .then(async (fd) => {
+            const buf = {
+              buffer: Buffer.allocUnsafe(16384),
+              offset: 0,
+              end: 0
+            };
+
+            const queryPromises = [];
+            let cmdError = null;
+            while (!cmdError) {
+              try {
+                const res = await fd.read(buf.buffer, buf.end, buf.buffer.length - buf.end, null);
+                if (res.bytesRead === 0) {
+                  // end of file reached.
+                  fd.close().catch(() => {});
+                  if (cmdError) {
+                    endingFunction();
+                    reject(cmdError);
+                    return;
+                  }
+                  await Promise.allSettled(queryPromises)
+                    .then(() => {
+                      // reset connection to initial database if was set
+                      if (
+                        !cmdParam.skipDbCheck &&
+                        prevDatabase &&
+                        cmdParam.database &&
+                        cmdParam.database !== prevDatabase
+                      ) {
+                        return new Promise(tmpQuery.bind(conn, `USE \`${prevDatabase.replace(/`/gi, '``')}\``));
+                      }
+                      return Promise.resolve();
+                    })
+                    .then(() => {
+                      endingFunction();
+                      if (cmdError) {
+                        reject(cmdError);
+                      } else {
+                        resolve();
+                      }
+                    })
+                    .catch((err) => {
+                      endingFunction();
+                      reject(err);
+                    });
+                  return;
+                } else {
+                  buf.end += res.bytesRead;
+                  const queries = Parse.parseQueries(buf);
+                  const queryIntermediatePromise = queries.flatMap((element) => {
+                    return new Promise(tmpQuery.bind(conn, element)).catch((err) => {
+                      cmdError = err;
+                    });
+                  });
+
+                  queryPromises.push(...queryIntermediatePromise);
+                  if (buf.offset === buf.end) {
+                    buf.offset = 0;
+                    buf.end = 0;
+                  } else {
+                    // ensure that buffer can at least read 8k bytes,
+                    // either by copying remaining data on used part or growing buffer
+                    if (buf.offset > 8192) {
+                      // reuse buffer, copying remaining data begin of buffer
+                      buf.buffer.copy(buf.buffer, 0, buf.offset, buf.end);
+                      buf.end -= buf.offset;
+                      buf.offset = 0;
+                    } else if (buf.buffer.length - buf.end < 8192) {
+                      // grow buffer
+                      const tmpBuf = Buffer.allocUnsafe(buf.buffer.length << 1);
+                      buf.buffer.copy(tmpBuf, 0, buf.offset, buf.end);
+                      buf.buffer = tmpBuf;
+                      buf.end -= buf.offset;
+                      buf.offset = 0;
+                    }
+                  }
+                }
+              } catch (e) {
+                fd.close().catch(() => {});
+                endingFunction();
+                Promise.allSettled(queryPromises).catch(() => {});
+                return reject(
+                  Errors.createError(
+                    e.message,
+                    Errors.ER_SQL_FILE_ERROR,
+                    conn.info,
+                    'HY000',
+                    null,
+                    false,
+                    cmdParam.stack
+                  )
+                );
+              }
+            }
+            if (cmdError) {
+              endingFunction();
+              reject(cmdError);
+            }
+          })
+          .catch((err) => {
+            endingFunction();
+            if (err.code === 'ENOENT') {
+              return reject(
+                Errors.createError(
+                  `SQL file parameter '${cmdParam.file}' doesn't exists`,
+                  Errors.ER_MISSING_SQL_FILE,
+                  conn.info,
+                  'HY000',
+                  null,
+                  false,
+                  cmdParam.stack
+                )
+              );
+            }
+            return reject(
+              Errors.createError(err.message, Errors.ER_SQL_FILE_ERROR, conn.info, 'HY000', null, false, cmdParam.stack)
+            );
+          });
+      });
+    });
+  }
 
   /**
    * Clearing connection variables when ending.
    *
    * @private
    */
-  const _clear = () => {
-    _sendQueue.clear();
-    opts.removeAllListeners();
-    _out = undefined;
-    _socket = undefined;
-  };
+  clear() {
+    this.sendQueue.clear();
+    this.opts.removeAllListeners();
+    this.streamOut = undefined;
+    this.socket = undefined;
+  }
 
-  //*****************************************************************
-  // internal variables
-  //*****************************************************************
+  /**
+   * Redirecting connection to server indicated value.
+   * @param value server host string
+   * @param resolve promise result when done
+   */
+  redirect(value, resolve) {
+    if (this.opts.permitRedirect && value) {
+      // redirect only if :
+      // * when pipelining, having received all waiting responses.
+      // * not in a transaction
+      if (this.receiveQueue.length <= 1 && (this.info.status & ServerStatus.STATUS_IN_TRANS) === 0) {
+        this.info.redirectRequest = null;
+        const matchResults = value.match(redirectUrlFormat);
+        if (!matchResults) {
+          if (this.opts.logger.error)
+            this.opts.logger.error(
+              new Error(
+                `error parsing redirection string '${value}'. format must be 'mariadb/mysql://[<user>[:<password>]@]<host>[:<port>]/[<db>[?<opt1>=<value1>[&<opt2>=<value2>]]]'`
+              )
+            );
+          return resolve();
+        }
 
-  EventEmitter.call(this);
-  const opts = Object.assign(new EventEmitter(), options);
-  const info = new ConnectionInformation();
-  const _sendQueue = new Queue();
-  const _receiveQueue = new Queue();
-  const _waitingAuthenticationQueue = new Queue();
-  let _status = Status.NOT_CONNECTED;
-  let _socketConnected = false;
-  let _socket = null;
-  let _timeout = null;
-  let _addCommand = _addCommandQueue;
-  const _fatalError = _fatalErrorHandler(this);
-  let _out = new PacketOutputStream(opts, info);
-  let _in = new PacketInputStream(_unexpectedPacket.bind(this), _receiveQueue, _out, opts, info);
-
-  this.query = this._queryPromise;
-  this.escape = Utils.escape.bind(this, opts, info);
-  this.escapeId = Utils.escapeId.bind(this, opts, info);
-
-  //add alias threadId for mysql/mysql2 compatibility
-  Object.defineProperty(this, 'threadId', {
-    get() {
-      return info ? info.threadId : undefined;
-    }
-  });
-  Object.defineProperty(this, 'info', {
-    get() {
-      return info;
-    }
-  });
+        const options = {
+          host: matchResults[7] ? decodeURIComponent(matchResults[7]) : matchResults[6],
+          port: matchResults[9] ? parseInt(matchResults[9]) : 3306
+        };
+
+        if (options.host === this.opts.host && options.port === this.opts.port) {
+          // redirection to the same host, skip loop redirection
+          return resolve();
+        }
+
+        // actually only options accepted are user and password
+        // there might be additional possible options in the future
+        if (matchResults[3]) options.user = matchResults[3];
+        if (matchResults[5]) options.password = matchResults[5];
+
+        const redirectOpts = ConnectionOptions.parseOptionDataType(options);
+
+        const finalRedirectOptions = new ConnOptions(Object.assign({}, this.opts, redirectOpts));
+        const conn = new Connection(finalRedirectOptions);
+        conn
+          .connect()
+          .then(
+            async function () {
+              await new Promise(this.end.bind(this, {}));
+              this.status = Status.CONNECTED;
+              this.info = conn.info;
+              this.opts = conn.opts;
+              this.socket = conn.socket;
+              if (this.prepareCache) this.prepareCache.reset();
+              this.streamOut = conn.streamOut;
+              this.streamIn = conn.streamIn;
+              resolve();
+            }.bind(this)
+          )
+          .catch(
+            function (e) {
+              if (this.opts.logger.error) {
+                const err = new Error(`fail to redirect to '${value}'`);
+                err.cause = e;
+                this.opts.logger.error(err);
+              }
+              resolve();
+            }.bind(this)
+          );
+      } else {
+        this.info.redirectRequest = value;
+        resolve();
+      }
+    } else {
+      this.info.redirectRequest = null;
+      resolve();
+    }
+  }
+
+  get threadId() {
+    return this.info ? this.info.threadId : null;
+  }
+
+  _sendNextCmdImmediate() {
+    if (!this.sendQueue.isEmpty()) {
+      setImmediate(this.nextSendCmd.bind(this));
+    }
+  }
+
+  _closePrepare(prepareResultPacket) {
+    this.addCommand(
+      new ClosePrepare(
+        {},
+        () => {},
+        () => {},
+        prepareResultPacket
+      ),
+      false
+    );
+  }
+
+  _logAndReject(reject, err) {
+    if (this.opts.logger.error) this.opts.logger.error(err);
+    reject(err);
+  }
 }
 
-util.inherits(Connection, EventEmitter);
+class TestMethods {
+  #collation;
+  #socket;
+
+  constructor(collation, socket) {
+    this.#collation = collation;
+    this.#socket = socket;
+  }
+
+  getCollation() {
+    return this.#collation;
+  }
+
+  getSocket() {
+    return this.#socket;
+  }
+}
 
 module.exports = Connection;