Convert function into class to cache the field definition

Author: testn

lib/commands/execute.js

@@ -85,10 +85,10 @@ class Execute extends Command {
     if (!packet.isEOF()) {
       return connection.protocolError('Expected EOF packet');
     }
-    this._rowParser = this.buildParserFromFields(
+    this._rowParser = new (this.buildParserFromFields(
       this._fields[this._resultIndex],
       connection
-    );
+    ))();
     return Execute.prototype.row;
   }
 }

lib/commands/query.js

@@ -212,7 +212,7 @@ class Query extends Command {
     if (this._receivedFieldsCount === this._fieldCount) {
       const fields = this._fields[this._resultIndex];
       this.emit('fields', fields);
-      this._rowParser = getTextParser(fields, this.options, connection.config);
+      this._rowParser = new (getTextParser(fields, this.options, connection.config))();
       return Query.prototype.fieldsEOF;
     }
     return Query.prototype.readField;
@@ -238,7 +238,7 @@ class Query extends Command {
     }
     let row;
     try {
-      row = this._rowParser(
+      row = this._rowParser.next(
         packet,
         this._fields[this._resultIndex],
         this.options,

lib/parsers/binary_parser.js

@@ -87,10 +87,12 @@ function compile(fields, options, config) {
   /* eslint-disable no-spaced-func */
   /* eslint-disable no-unexpected-multiline */
 
-  parserFn('(function(){')(
-    'return function BinaryRow(packet, fields, options, CharsetToEncoding) {'
-  );
+  parserFn('(function(){');
+  parserFn('return class BinaryRow {');
+  parserFn('constructor() {');
+  parserFn('}');
 
+  parserFn('next(packet, fields, options) {');
   if (options.rowsAsArray) {
     parserFn(`const result = new Array(${fields.length});`);
   } else {
@@ -161,7 +163,7 @@ function compile(fields, options, config) {
   }
 
   parserFn('return result;');
-
+  parserFn('}');
   parserFn('};')('})()');
 
   /* eslint-enable no-trailing-spaces */

lib/parsers/parser_cache.js

@@ -20,13 +20,7 @@ function keyFromFields(type, fields, options, config) {
     `/${options.dateStrings}`;
   for (let i = 0; i < fields.length; ++i) {
     const field = fields[i];
-    res += `/${field.name}:${field.columnType}:${field.flags}:${
-      field.characterSet
-    }`;
-
-    if (options.nestTables) {
-      res += `:${field.table}`
-    }
+    res += `/${field.name}:${field.columnType}:${field.length}:${field.schema}:${field.table}:${field.flags}:${field.characterSet}`;
   }
   return res;
 }

lib/parsers/text_parser.js

@@ -70,27 +70,6 @@ function readCodeFor(type, charset, encodingExpr, config, options) {
 }
 
 function compile(fields, options, config) {
-  // node-mysql typeCast compatibility wrapper
-  // see https://github.com/mysqljs/mysql/blob/96fdd0566b654436624e2375c7b6604b1f50f825/lib/protocol/packets/Field.js
-  function wrap(field, type, packet, encoding) {
-    return {
-      type: type,
-      length: field.columnLength,
-      db: field.schema,
-      table: field.table,
-      name: field.name,
-      string: function() {
-        return packet.readLengthCodedString(encoding);
-      },
-      buffer: function() {
-        return packet.readLengthCodedBuffer();
-      },
-      geometry: function() {
-        return packet.parseGeometryValue();
-      }
-    };
-  }
-
   // use global typeCast if current query doesn't specify one
   if (
     typeof config.typeCast === 'function' &&
@@ -100,41 +79,78 @@ function compile(fields, options, config) {
   }
 
   const parserFn = genFunc();
-  let i = 0;
 
   /* eslint-disable no-trailing-spaces */
   /* eslint-disable no-spaced-func */
   /* eslint-disable no-unexpected-multiline */
   parserFn('(function () {')(
-    'return function TextRow(packet, fields, options, CharsetToEncoding) {'
+    'return class TextRow {'
   );
 
-  if (options.rowsAsArray) {
-    parserFn(`const result = new Array(${fields.length})`);
-  } else {
-    parserFn("const result = {}");
+  // constructor method
+  parserFn('constructor() {');
+  // node-mysql typeCast compatibility wrapper
+  // see https://github.com/mysqljs/mysql/blob/96fdd0566b654436624e2375c7b6604b1f50f825/lib/protocol/packets/Field.js
+  if (typeof options.typeCast === 'function') {
+    parserFn('const _this = this;');
+    for(let i=0; i<fields.length; ++i) {
+      const field = fields[i];
+      const encodingExpr = `fields[${i}].encoding`;
+      const readCode = readCodeFor(
+        fields[i].columnType,
+        fields[i].characterSet,
+        encodingExpr,
+        config,
+        options
+      );
+      parserFn(`this.wrap${i} = {
+        type: ${helpers.srcEscape(typeNames[field.columnType])},
+        length: ${helpers.srcEscape(field.columnLength)},
+        db: ${helpers.srcEscape(field.schema)},
+        table: ${helpers.srcEscape(field.table)},
+        name: ${helpers.srcEscape(field.name)},
+        string: function() {
+          return _this.packet.readLengthCodedString(${helpers.srcEscape(field.encoding)});
+        },
+        buffer: function() {
+          return _this.packet.readLengthCodedBuffer();
+        },
+        geometry: function() {
+          return _this.packet.parseGeometryValue();
+        },
+        readNext: function() {
+          return _this.${readCode};
+        }
+      };`);
+    }
   }
+  parserFn('}');
 
-  if (typeof options.typeCast === 'function') {
-    parserFn(`const wrap = ${wrap.toString()}`);
+  // next method
+  parserFn('next(packet, fields, options) {');
+  parserFn("this.packet = packet;");
+  if (options.rowsAsArray) {
+    parserFn(`const result = new Array(${fields.length});`);
+  } else {
+    parserFn("const result = {};");
   }
 
   const resultTables = {};
   let resultTablesArray = [];
 
   if (options.nestTables === true) {
-    for (i = 0; i < fields.length; i++) {
+    for (let i=0; i < fields.length; i++) {
       resultTables[fields[i].table] = 1;
     }
     resultTablesArray = Object.keys(resultTables);
-    for (i = 0; i < resultTablesArray.length; i++) {
+    for (let i=0; i < resultTablesArray.length; i++) {
       parserFn(`result[${helpers.srcEscape(resultTablesArray[i])}] = {};`);
     }
   }
 
   let lvalue = '';
   let fieldName = '';
-  for (i = 0; i < fields.length; i++) {
+  for (let i = 0; i < fields.length; i++) {
     fieldName = helpers.srcEscape(fields[i].name);
     parserFn(`// ${fieldName}: ${typeNames[fields[i].columnType]}`);
     if (typeof options.nestTables === 'string') {
@@ -148,29 +164,25 @@ function compile(fields, options, config) {
     } else {
       lvalue = `result[${fieldName}]`;
     }
-    const encodingExpr = `CharsetToEncoding[fields[${i}].characterSet]`;
-    const readCode = readCodeFor(
-      fields[i].columnType,
-      fields[i].characterSet,
-      encodingExpr,
-      config,
-      options
-    );
     if (typeof options.typeCast === 'function') {
-      parserFn(
-        `${lvalue} = options.typeCast(wrap(fields[${i}], ${helpers.srcEscape(
-          typeNames[fields[i].columnType]
-        )}, packet, ${encodingExpr}), function() { return ${readCode};})`
-      );
+      parserFn(`${lvalue} = options.typeCast(this.wrap${i}, this.wrap${i}.readNext);`);
     } else if (options.typeCast === false) {
       parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
     } else {
+      const encodingExpr = `fields[${i}].encoding`;
+      const readCode = readCodeFor(
+        fields[i].columnType,
+        fields[i].characterSet,
+        encodingExpr,
+        config,
+        options
+      );
       parserFn(`${lvalue} = ${readCode};`);
     }
   }
 
   parserFn('return result;');
-
+  parserFn('}');
   parserFn('};')('})()');
 
   /* eslint-enable no-trailing-spaces */

test/unit/commands/test-query.js

@@ -9,9 +9,11 @@ const testQuery = new Query({}, (err, res) => {
   assert.equal(res, null);
 });
 
-testQuery._rowParser = function FailingRowParser() {
-  throw testError;
-}
+testQuery._rowParser = new class FailingRowParser {
+  next() {
+    throw testError;
+  }
+}();
 
 testQuery.row({
   isEOF: () => false