mysql2 2.3.3 → 3.0.0

package/README.md

@@ -6,7 +6,9 @@
 [![Node.js Version][node-version-image]][node-version-url]
 [![Linux Build][travis-image]][travis-url]
 [![Windows Build][appveyor-image]][appveyor-url]
-[![License][license-image]][license-url]
+[![License][license-image]][license-url]  
+
+English | [简体中文](./documentation_zh-cn/)
 
 > MySQL client for Node.js with focus on performance. Supports prepared statements, non-utf8 encodings, binary log protocol, compression, ssl [much more](https://github.com/sidorares/node-mysql2/tree/master/documentation)
 
@@ -246,7 +248,9 @@ con.query({ sql: 'select 1 as foo, 2 as foo', rowsAsArray: true }, function(err,
 
 MySQL2 is mostly API compatible with [Node MySQL][node-mysql]. You should check their API documentation to see all available API options.
 
-If you find any incompatibility with [Node MySQL][node-mysql], Please report via Issue tracker. We will fix reported incompatibility on priority basis.
+One known incompatibility is that `DECIMAL` values are returned as strings whereas in [Node MySQL][node-mysql] they are returned as numbers. This includes the result of `SUM()` and `AVG()` functions when applied to `INTEGER` arguments. This is done deliberately to avoid loss of precision - see https://github.com/sidorares/node-mysql2/issues/935.
+
+If you find any other incompatibility with [Node MySQL][node-mysql], Please report via Issue tracker. We will fix reported incompatibility on priority basis.
 
 ## Documentation
 

package/index.d.ts

@@ -1,7 +1,7 @@
 import {
   Connection as PromiseConnection,
   Pool as PromisePool,
-  PoolConnection as PromisePoolConnection
+  PoolConnection as PromisePoolConnection,
 } from './promise';
 
 import * as mysql from './typings/mysql';
@@ -72,6 +72,15 @@ export interface Connection extends mysql.Connection {
   ): mysql.Query;
   ping(callback?: (err: mysql.QueryError | null) => any): void;
   promise(promiseImpl?: PromiseConstructor): PromiseConnection;
+  unprepare(sql: string): mysql.PrepareStatementInfo;
+  prepare(sql: string, callback?: (err: mysql.QueryError | null, statement: mysql.PrepareStatementInfo) => any): mysql.Prepare;
+  serverHandshake(args: any): any;
+  writeOk(args?: mysql.OkPacketParams): void;
+  writeError(args?: mysql.ErrorPacketParams): void;
+  writeEof(warnings?: number, statusFlags?: number): void;
+  writeTextResult(rows?: Array<any>, columns?: Array<any>): void;
+  writePacket(packet: any): void;
+  sequenceId: number;
 }
 
 export interface PoolConnection extends mysql.PoolConnection, Connection {
@@ -149,14 +158,11 @@ export interface Pool extends mysql.Connection {
   on(event: 'release', listener: (connection: PoolConnection) => any): this;
   on(event: 'enqueue', listener: () => any): this;
   promise(promiseImpl?: PromiseConstructor): PromisePool;
-}
+  unprepare(sql: string): mysql.PrepareStatementInfo;
+  prepare(sql: string, callback?: (err: mysql.QueryError | null, statement: mysql.PrepareStatementInfo) => any): mysql.Prepare;
 
-type authPlugins = (pluginMetadata: {
-  connection: Connection;
-  command: string;
-}) => (
-  pluginData: Buffer
-) => Promise<string> | string | Buffer | Promise<Buffer> | null;
+  config: mysql.PoolOptions;
+}
 
 export interface ConnectionOptions extends mysql.ConnectionOptions {
   charsetNumber?: number;
@@ -178,10 +184,18 @@ export interface ConnectionOptions extends mysql.ConnectionOptions {
   queueLimit?: number;
   waitForConnections?: boolean;
   authPlugins?: {
-    [key: string]: authPlugins;
+    [key: string]: mysql.AuthPlugin;
   };
 }
 
+export interface ConnectionConfig extends ConnectionOptions {
+  mergeFlags(defaultFlags: string[], userFlags: string[] | string): number;
+  getDefaultFlags(options?: ConnectionOptions): string[];
+  getCharsetNumber(charset: string): number;
+  getSSLProfile(name: string): { ca: string[] };
+  parseUrl(url: string): { host: string, port: number, database: string, user: string, password: string, [key: string]: any };
+}
+
 export interface PoolOptions extends mysql.PoolOptions, ConnectionOptions {}
 
 export function createConnection(connectionUri: string): Connection;

package/index.js

@@ -12,6 +12,7 @@ exports.createConnection = function(opts) {
 
 exports.connect = exports.createConnection;
 exports.Connection = Connection;
+exports.ConnectionConfig = ConnectionConfig;
 
 const Pool = require('./lib/pool.js');
 const PoolCluster = require('./lib/pool_cluster.js');
@@ -42,6 +43,7 @@ exports.createServer = function(handler) {
 };
 
 exports.PoolConnection = require('./lib/pool_connection');
+exports.authPlugins = require('./lib/auth_plugins');
 exports.escape = SqlString.escape;
 exports.escapeId = SqlString.escapeId;
 exports.format = SqlString.format;

package/lib/auth_plugins/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  caching_sha2_password: require('./caching_sha2_password'),
+  mysql_clear_password: require('./mysql_clear_password'),
+  mysql_native_password: require('./mysql_native_password'),
+  sha256_password: require('./sha256_password'),
+};

package/lib/auth_plugins/mysql_clear_password.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function bufferFromStr(str) {
+  return Buffer.from(`${str}\0`);
+}
+
+const create_mysql_clear_password_plugin = pluginOptions =>
+  function mysql_clear_password_plugin({ connection, command }) {
+    const password =
+      command.password || pluginOptions.password || connection.config.password;
+
+    return function (/* pluginData */) {
+      return bufferFromStr(password);
+    };
+  };
+
+module.exports = create_mysql_clear_password_plugin;

package/lib/auth_plugins/sha256_password.js

@@ -2,7 +2,7 @@
 
 const PLUGIN_NAME = 'sha256_password';
 const crypto = require('crypto');
-const { xor } = require('../auth_41');
+const { xorRotating } = require('../auth_41');
 
 const REQUEST_SERVER_KEY_PACKET = Buffer.from([1]);
 
@@ -11,7 +11,7 @@ const STATE_WAIT_SERVER_KEY = 1;
 const STATE_FINAL = -1;
 
 function encrypt(password, scramble, key) {
-  const stage1 = xor(
+  const stage1 = xorRotating(
     Buffer.from(`${password}\0`, 'utf8').toString('binary'),
     scramble.toString('binary')
   );

package/lib/commands/auth_switch.js

@@ -9,11 +9,13 @@ const Packets = require('../packets/index.js');
 const sha256_password = require('../auth_plugins/sha256_password');
 const caching_sha2_password = require('../auth_plugins/caching_sha2_password.js');
 const mysql_native_password = require('../auth_plugins/mysql_native_password.js');
+const mysql_clear_password = require('../auth_plugins/mysql_clear_password.js');
 
 const standardAuthPlugins = {
   sha256_password: sha256_password({}),
   caching_sha2_password: caching_sha2_password({}),
-  mysql_native_password: mysql_native_password({})
+  mysql_native_password: mysql_native_password({}),
+  mysql_clear_password: mysql_clear_password({})
 };
 
 function warnLegacyAuthSwitch() {

package/lib/commands/change_user.js

@@ -1,7 +1,14 @@
+// This file was modified by Oracle on September 21, 2021.
+// The changes involve saving additional authentication factor passwords
+// in the command scope and enabling multi-factor authentication in the
+// client-side when the server supports it.
+// Modifications copyright (c) 2021, Oracle and/or its affiliates.
+
 'use strict';
 
 const Command = require('./command.js');
 const Packets = require('../packets/index.js');
+const ClientConstants = require('../constants/client');
 const ClientHandshake = require('./client_handshake.js');
 const CharsetToEncoding = require('../constants/charset_encodings.js');
 
@@ -11,10 +18,15 @@ class ChangeUser extends Command {
     this.onResult = callback;
     this.user = options.user;
     this.password = options.password;
+    // "password1" is an alias of "password"
+    this.password1 = options.password;
+    this.password2 = options.password2;
+    this.password3 = options.password3;
     this.database = options.database;
     this.passwordSha1 = options.passwordSha1;
     this.charsetNumber = options.charsetNumber;
     this.currentConfig = options.currentConfig;
+    this.authenticationFactor = 0;
   }
   start(packet, connection) {
     const newPacket = new Packets.ChangeUser({
@@ -35,6 +47,13 @@ class ChangeUser extends Command {
     // reset prepared statements cache as all statements become invalid after changeUser
     connection._statements.reset();
     connection.writePacket(newPacket.toPacket());
+    // check if the server supports multi-factor authentication
+    const multiFactorAuthentication = connection.serverCapabilityFlags & ClientConstants.MULTI_FACTOR_AUTHENTICATION;
+    if (multiFactorAuthentication) {
+      // if the server supports multi-factor authentication, we enable it in
+      // the client
+      this.authenticationFactor = 1;
+    }
     return ChangeUser.prototype.handshakeResult;
   }
 }

package/lib/commands/client_handshake.js

@@ -3,6 +3,11 @@
 // emitted in the command instance itself.
 // Modifications copyright (c) 2021, Oracle and/or its affiliates.
 
+// This file was modified by Oracle on September 21, 2021.
+// Handshake workflow now supports additional authentication factors requested
+// by the server.
+// Modifications copyright (c) 2021, Oracle and/or its affiliates.
+
 'use strict';
 
 const Command = require('./command.js');
@@ -26,6 +31,7 @@ class ClientHandshake extends Command {
     super();
     this.handshake = null;
     this.clientFlags = clientFlags;
+    this.authenticationFactor = 0;
   }
 
   start() {
@@ -51,6 +57,14 @@ class ClientHandshake extends Command {
     }
     this.user = connection.config.user;
     this.password = connection.config.password;
+    // "password1" is an alias to the original "password" value
+    // to make it easier to integrate multi-factor authentication
+    this.password1 = connection.config.password;
+    // "password2" and "password3" are the 2nd and 3rd factor authentication
+    // passwords, which can be undefined depending on the authentication
+    // plugin being used
+    this.password2 = connection.config.password2;
+    this.password3 = connection.config.password3;
     this.passwordSha1 = connection.config.passwordSha1;
     this.database = connection.config.database;
     this.autPluginName = this.handshake.autPluginName;
@@ -109,6 +123,12 @@ class ClientHandshake extends Command {
     connection.connectionId = this.handshake.connectionId;
     const serverSSLSupport =
       this.handshake.capabilityFlags & ClientConstants.SSL;
+    // multi factor authentication is enabled with the
+    // "MULTI_FACTOR_AUTHENTICATION" capability and should only be used if it
+    // is supported by the server
+    const multiFactorAuthentication =
+      this.handshake.capabilityFlags & ClientConstants.MULTI_FACTOR_AUTHENTICATION;
+    this.clientFlags = this.clientFlags | multiFactorAuthentication;
     // use compression only if requested by client and supported by server
     connection.config.compress =
       connection.config.compress &&
@@ -141,17 +161,36 @@ class ClientHandshake extends Command {
     } else {
       this.sendCredentials(connection);
     }
+    if (multiFactorAuthentication) {
+      // if the server supports multi-factor authentication, we enable it in
+      // the client
+      this.authenticationFactor = 1;
+    }
     return ClientHandshake.prototype.handshakeResult;
   }
 
   handshakeResult(packet, connection) {
     const marker = packet.peekByte();
-    if (marker === 0xfe || marker === 1) {
+    // packet can be OK_Packet, ERR_Packet, AuthSwitchRequest, AuthNextFactor
+    // or AuthMoreData
+    if (marker === 0xfe || marker === 1 || marker === 0x02) {
       const authSwitch = require('./auth_switch');
       try {
         if (marker === 1) {
           authSwitch.authSwitchRequestMoreData(packet, connection, this);
         } else {
+          // if authenticationFactor === 0, it means the server does not support
+          // the multi-factor authentication capability
+          if (this.authenticationFactor !== 0) {
+            // if we are past the first authentication factor, we should use the
+            // corresponding password (if there is one)
+            connection.config.password = this[`password${this.authenticationFactor}`];
+            // update the current authentication factor
+            this.authenticationFactor += 1;
+          }
+          // if marker === 0x02, it means it is an AuthNextFactor packet,
+          // which is similar in structure to an AuthSwitchRequest packet,
+          // so, we can use it directly
           authSwitch.authSwitchRequest(packet, connection, this);
         }
         return ClientHandshake.prototype.handshakeResult;

package/lib/commands/prepare.js

@@ -55,7 +55,8 @@ class Prepare extends Command {
     }
     const cmdPacket = new Packets.PrepareStatement(
       this.query,
-      connection.config.charsetNumber
+      connection.config.charsetNumber,
+      this.options.values
     );
     connection.writePacket(cmdPacket.toPacket(1));
     return Prepare.prototype.prepareHeader;

package/lib/commands/quit.js

@@ -7,7 +7,7 @@ const Packet = require('../packets/packet.js');
 class Quit extends Command {
   constructor(callback) {
     super();
-    this.done = callback;
+    this.onResult = callback;
   }
 
   start(packet, connection) {
@@ -18,8 +18,8 @@ class Quit extends Command {
       0,
       5
     );
-    if (this.done) {
-      this.done();
+    if (this.onResult) {
+      this.onResult();
     }
     connection.writePacket(quit);
     return null;

package/lib/commands/server_handshake.js

@@ -69,12 +69,41 @@ class ServerHandshake extends Command {
     return ServerHandshake.prototype.dispatchCommands;
   }
 
+  _isStatement(query, name) {
+    const firstWord = query.split(' ')[0].toUpperCase();
+    return firstWord === name;
+  }
+
   dispatchCommands(packet, connection) {
     // command from client to server
     let knownCommand = true;
     const encoding = connection.clientHelloReply.encoding;
     const commandCode = packet.readInt8();
     switch (commandCode) {
+      case CommandCode.STMT_PREPARE:
+        if (connection.listeners('stmt_prepare').length) {
+          const query = packet.readString(undefined, encoding);
+          connection.emit('stmt_prepare', query);
+        } else {
+          connection.writeError({
+            code: Errors.HA_ERR_INTERNAL_ERROR,
+            message:
+              'No query handler for prepared statements.'
+          });
+        }
+        break;
+      case CommandCode.STMT_EXECUTE:
+        if (connection.listeners('stmt_execute').length) {
+          const { stmtId, flags, iterationCount, values } = Packets.Execute.fromPacket(packet, encoding);
+          connection.emit('stmt_execute', stmtId, flags, iterationCount, values);
+        } else {
+          connection.writeError({
+            code: Errors.HA_ERR_INTERNAL_ERROR,
+            message:
+              'No query handler for execute statements.'
+          });
+        }
+        break;
       case CommandCode.QUIT:
         if (connection.listeners('quit').length) {
           connection.emit('quit');
@@ -93,7 +122,13 @@ class ServerHandshake extends Command {
       case CommandCode.QUERY:
         if (connection.listeners('query').length) {
           const query = packet.readString(undefined, encoding);
-          connection.emit('query', query);
+          if (this._isStatement(query, 'PREPARE') || this._isStatement(query, 'SET')) {
+            connection.emit('stmt_prepare', query);
+          }
+          else if (this._isStatement(query, 'EXECUTE')) {
+            connection.emit('stmt_execute', null, null, null, null, query);
+          }
+          else connection.emit('query', query);
         } else {
           connection.writeError({
             code: Errors.HA_ERR_INTERNAL_ERROR,

package/lib/connection.js

@@ -8,6 +8,11 @@
 // there is a fatal error.
 // Modifications copyright (c) 2021, Oracle and/or its affiliates.
 
+// This file was modified by Oracle on September 21, 2021.
+// The changes involve passing additional authentication factor passwords
+// to the ChangeUser Command instance.
+// Modifications copyright (c) 2021, Oracle and/or its affiliates.
+
 'use strict';
 
 const Net = require('net');
@@ -50,6 +55,10 @@ class Connection extends EventEmitter {
         // Enable keep-alive on the socket.  It's disabled by default, but the
         // user can enable it and supply an initial delay.
         this.stream.setKeepAlive(true, this.config.keepAliveInitialDelay);
+
+        // Enable TCP_NODELAY flag. This is needed so that the network packets
+        // are sent immediately to the server
+        this.stream.setNoDelay(true);
       }
       // if stream is a function, treat it as "stream agent / factory"
     } else if (typeof opts.config.stream === 'function')  {
@@ -65,7 +74,7 @@ class Connection extends EventEmitter {
     this._paused_packets = new Queue();
     this._statements = new LRU({
       max: this.config.maxPreparedStatements,
-      dispose: function(key, statement) {
+      dispose: function(statement) {
         statement.close();
       }
     });
@@ -91,6 +100,10 @@ class Connection extends EventEmitter {
       }
       this.packetParser.execute(data);
     });
+    this.stream.on('end', () => {
+      // emit the end event so that the pooled connection can close the connection
+      this.emit('end');
+    });
     this.stream.on('close', () => {
       // we need to set this flag everywhere where we want connection to close
       if (this._closing) {
@@ -112,7 +125,7 @@ class Connection extends EventEmitter {
       handshakeCommand.on('end', () => {
         // this happens when handshake finishes early either because there was
         // some fatal error or the server sent an error packet instead of
-        // an hello packet (for example, 'Too many connactions' error)
+        // an hello packet (for example, 'Too many connections' error)
         if (!handshakeCommand.handshake || this._fatalError || this._protocolError) {
           return;
         }
@@ -126,9 +139,9 @@ class Connection extends EventEmitter {
       });
       this.addCommand(handshakeCommand);
     }
-    // in case there was no initiall handshake but we need to read sting, assume it utf-8
+    // in case there was no initial handshake but we need to read sting, assume it utf-8
     // most common example: "Too many connections" error ( packet is sent immediately on connection attempt, we don't know server encoding yet)
-    // will be overwrittedn with actial encoding value as soon as server handshake packet is received
+    // will be overwritten with actual encoding value as soon as server handshake packet is received
     this.serverEncoding = 'utf8';
     if (this.config.connectTimeout) {
       const timeoutHandler = this._handleTimeoutError.bind(this);
@@ -174,7 +187,7 @@ class Connection extends EventEmitter {
       this.connectTimeout = null;
     }
     // Do not throw an error when a connection ends with a RST,ACK packet
-    if (err.errno === 'ECONNRESET' && this._closing) {
+    if (err.code === 'ECONNRESET' && this._closing) {
       return;
     }
     this._handleFatalError(err);
@@ -337,6 +350,9 @@ class Connection extends EventEmitter {
       minVersion: this.config.ssl.minVersion
     });
     const rejectUnauthorized = this.config.ssl.rejectUnauthorized;
+    const verifyIdentity = this.config.ssl.verifyIdentity;
+    const host = this.config.host;
+
     let secureEstablished = false;
     const secureSocket = new Tls.TLSSocket(this.stream, {
       rejectUnauthorized: rejectUnauthorized,
@@ -344,6 +360,9 @@ class Connection extends EventEmitter {
       secureContext: secureContext,
       isServer: false
     });
+    if (typeof host === 'string') {
+      secureSocket.setServername(host);
+    }
     // error handler for secure socket
     secureSocket.on('_tlsError', err => {
       if (secureEstablished) {
@@ -354,7 +373,15 @@ class Connection extends EventEmitter {
     });
     secureSocket.on('secure', () => {
       secureEstablished = true;
-      onSecure(rejectUnauthorized ? secureSocket.ssl.verifyError() : null);
+      let callbackValue = null;
+      if (rejectUnauthorized) {
+        callbackValue = secureSocket.ssl.verifyError()
+        if (!callbackValue && typeof host === 'string' && verifyIdentity) {
+          const cert = secureSocket.ssl.getPeerCertificate(true);
+          callbackValue = Tls.checkServerIdentity(host, cert)
+        }
+      }
+      onSecure(callbackValue);
     });
     secureSocket.on('data', data => {
       this.packetParser.execute(data);
@@ -396,6 +423,10 @@ class Connection extends EventEmitter {
     err.code = code || 'PROTOCOL_ERROR';
     this.emit('error', err);
   }
+  
+  get fatalError() {
+    return this._fatalError;
+  }
 
   handlePacket(packet) {
     if (this._paused) {
@@ -556,7 +587,7 @@ class Connection extends EventEmitter {
     this._paused = false;
     while ((packet = this._paused_packets.shift())) {
       this.handlePacket(packet);
-      // don't resume if packet hander paused connection
+      // don't resume if packet handler paused connection
       if (this._paused) {
         return;
       }
@@ -582,7 +613,7 @@ class Connection extends EventEmitter {
     const key = Connection.statementKey(options);
     const stmt = this._statements.get(key);
     if (stmt) {
-      this._statements.del(key);
+      this._statements.delete(key);
       stmt.close();
     }
     return stmt;
@@ -671,7 +702,12 @@ class Connection extends EventEmitter {
       new Commands.ChangeUser(
         {
           user: options.user || this.config.user,
-          password: options.password || this.config.password,
+          // for the purpose of multi-factor authentication, or not, the main
+          // password (used for the 1st authentication factor) can also be
+          // provided via the "password1" option
+          password: options.password || options.password1 || this.config.password || this.config.password1,
+          password2: options.password2 || this.config.password2,
+          password3: options.password3 || this.config.password3,
           passwordSha1: options.passwordSha1 || this.config.passwordSha1,
           database: options.database || this.config.database,
           timeout: options.timeout,
@@ -804,14 +840,23 @@ class Connection extends EventEmitter {
     );
   }
 
-  writeTextResult(rows, columns) {
+  writeBinaryRow(column) {
+    this.writePacket(
+      Packets.BinaryRow.toPacket(column, this.serverConfig.encoding)
+    );
+  }
+
+  writeTextResult(rows, columns, binary=false) {
     this.writeColumns(columns);
     rows.forEach(row => {
       const arrayRow = new Array(columns.length);
       columns.forEach(column => {
         arrayRow.push(row[column.name]);
       });
-      this.writeTextRow(arrayRow);
+      if(binary) {
+        this.writeBinaryRow(arrayRow);
+      }
+      else this.writeTextRow(arrayRow);
     });
     this.writeEof();
   }

package/lib/connection_config.js

@@ -1,3 +1,10 @@
+// This file was modified by Oracle on September 21, 2021.
+// New connection options for additional authentication factors were
+// introduced.
+// Multi-factor authentication capability is now enabled if one of these
+// options is used.
+// Modifications copyright (c) 2021, Oracle and/or its affiliates.
+
 'use strict';
 
 const { URL } = require('url');
@@ -30,6 +37,11 @@ const validOptions = {
   namedPlaceholders: 1,
   nestTables: 1,
   password: 1,
+  // with multi-factor authentication, the main password (used for the first
+  // authentication factor) can be provided via password1
+  password1: 1,
+  password2: 1,
+  password3: 1,
   passwordSha1: 1,
   pool: 1,
   port: 1,
@@ -81,7 +93,12 @@ class ConnectionConfig {
     this.localAddress = options.localAddress;
     this.socketPath = options.socketPath;
     this.user = options.user || undefined;
-    this.password = options.password || undefined;
+    // for the purpose of multi-factor authentication, or not, the main
+    // password (used for the 1st authentication factor) can also be
+    // provided via the "password1" option
+    this.password = options.password || options.password1 || undefined;
+    this.password2 = options.password2 || undefined;
+    this.password3 = options.password3 || undefined;
     this.passwordSha1 = options.passwordSha1 || undefined;
     this.database = options.database;
     this.connectTimeout = isNaN(options.connectTimeout)
@@ -128,7 +145,7 @@ class ConnectionConfig {
       // "+" is a url encoded char for space so it
       // gets translated to space when giving a
       // connection string..
-      this.timezone = `+${this.timezone.substr(1)}`;
+      this.timezone = `+${this.timezone.slice(1)}`;
     }
     if (this.ssl) {
       if (typeof this.ssl !== 'object') {
@@ -236,7 +253,7 @@ class ConnectionConfig {
     const options = {
       host: parsedUrl.hostname,
       port: parsedUrl.port,
-      database: parsedUrl.pathname.substr(1),
+      database: parsedUrl.pathname.slice(1),
       user: parsedUrl.username,
       password: parsedUrl.password
     };

package/lib/constants/charset_encodings.js

@@ -104,7 +104,7 @@ module.exports = [
   'eucjpms',
   'eucjpms',
   'cp1250',
-  'utf8',
+  'utf16',
   'utf16',
   'utf16',
   'utf16',
@@ -309,5 +309,8 @@ module.exports = [
   'utf8',
   'utf8',
   'utf8',
+  'utf8',
+  'utf8',
+  'utf8',
   'utf8'
 ];