@vlasky/zongji 0.6.0 → 0.7.0

package/index.js

@@ -7,23 +7,18 @@ const ConnectionConfigMap = {
   'Pool': obj => obj.config.connectionConfig,
 };
 
-const TableInfoQueryTemplate = `SELECT
+const TableInfoQuery = `SELECT
   COLUMN_NAME, COLLATION_NAME, CHARACTER_SET_NAME,
   COLUMN_COMMENT, COLUMN_TYPE
-  FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA='%s' AND TABLE_NAME='%s'
+  FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA=? AND TABLE_NAME=?
   ORDER BY ORDINAL_POSITION`;
 
-// Simple format function to replace %s placeholders
-function formatSql(template, ...args) {
-  let i = 0;
-  return template.replace(/%s/g, () => args[i++]);
-}
-
 class ZongJi extends EventEmitter {
   constructor(dsn) {
     super();
 
     this._pendingErrors = [];
+    this._pendingErrorTimer = null;
     this.on('newListener', (event) => {
       if (event !== 'error' || this._pendingErrors.length === 0) {
         return;
@@ -39,8 +34,12 @@ class ZongJi extends EventEmitter {
     this._filters({});
     this.ctrlCallbacks = [];
     this.tableMap = {};
+    this._warnedUnsupported = new Set();
+    this._currentGtid = undefined;
     this.ready = false;
     this.stopped = false;
+    this._starting = false;
+    this._startEpoch = 0;
     this.useChecksum = false;
 
     this._dsn = dsn;
@@ -54,7 +53,12 @@ class ZongJi extends EventEmitter {
     const createConnection = (options) => {
       const emitError = (err) => {
         if (this.listenerCount('error') === 0) {
+          // Buffer errors that fire before the caller attaches a listener
+          // (typically within the same tick as construction/start). If no
+          // listener ever appears, fall back to EventEmitter's default
+          // behaviour (throw) rather than swallowing failures silently.
           this._pendingErrors.push(err);
+          this._schedulePendingErrorCheck();
           return;
         }
         this.emit('error', err);
@@ -95,6 +99,23 @@ class ZongJi extends EventEmitter {
     this.connection = createConnection(binlogDsn);
   }
 
+  _schedulePendingErrorCheck() {
+    if (this._pendingErrorTimer) {
+      return;
+    }
+    this._pendingErrorTimer = setImmediate(() => {
+      this._pendingErrorTimer = null;
+      if (this.listenerCount('error') > 0 || this._pendingErrors.length === 0) {
+        return;
+      }
+      const pending = this._pendingErrors.slice();
+      this._pendingErrors.length = 0;
+      // No 'error' listener was attached within a macrotask; re-emit so
+      // Node's unhandled 'error' semantics apply (throws)
+      pending.forEach(err => this.emit('error', err));
+    });
+  }
+
   _isChecksumEnabled(next) {
     const SelectChecksumParamSql = 'select @@GLOBAL.binlog_checksum as checksum';
     const SetChecksumSql = 'set @master_binlog_checksum=@@global.binlog_checksum';
@@ -184,19 +205,28 @@ class ZongJi extends EventEmitter {
   }
 
   _fetchTableInfo(tableMapEvent, next) {
-    const sql = formatSql(TableInfoQueryTemplate,
-      tableMapEvent.schemaName, tableMapEvent.tableName);
-
     if (!this.ctrlConnection ||
         this.ctrlConnection.state === 'disconnected' ||
         this.ctrlConnection._fatalError ||
         this.ctrlConnection._protocolError ||
         this.ctrlConnection._closing) {
+      // The binlog connection stays paused, so processing has halted.
+      // During stop() that is expected; otherwise it must not be silent.
+      if (!this.stopped) {
+        this.emit('error', new Error(
+          'Control connection unavailable while fetching column metadata ' +
+          'for ' + tableMapEvent.schemaName + '.' + tableMapEvent.tableName +
+          '. Binlog processing has halted; call stop() then start() to resume.'));
+      }
       return;
     }
 
+    const params = [tableMapEvent.schemaName, tableMapEvent.tableName];
     try {
-      this.ctrlConnection.query(sql, (err, rows) => {
+      // execute() uses a server-side prepared statement: parameters are sent
+      // out-of-band (never spliced into SQL text) and the statement is cached
+      // per connection, so repeated metadata lookups avoid re-parsing.
+      this.ctrlConnection.execute(TableInfoQuery, params, (err, rows) => {
       if (err) {
         // Errors should be emitted
         this.emit('error', err);
@@ -234,12 +264,14 @@ class ZongJi extends EventEmitter {
     filename,
     position,
     startAtEnd,
+    nonBlock,
   } = {}) {
     this.options = {
       serverId,
       filename,
       position,
       startAtEnd,
+      nonBlock,
     };
   }
 
@@ -257,6 +289,28 @@ class ZongJi extends EventEmitter {
       includeSchema,
       excludeSchema,
     };
+
+    // Precompiled lookups so per-event filtering is O(1). Only own keys of
+    // the schema objects are considered (no prototype leakage).
+    const compileSchemaFilter = (schema) => {
+      if (schema === undefined || schema === null) {
+        return undefined;
+      }
+      const compiled = new Map();
+      for (const database of Object.keys(schema)) {
+        const tables = schema[database];
+        compiled.set(database, tables === true ?
+          true : new Set(Array.isArray(tables) ? tables : []));
+      }
+      return compiled;
+    };
+
+    this._includeEventsSet = includeEvents === undefined ?
+      undefined : new Set(Array.isArray(includeEvents) ? includeEvents : []);
+    this._excludeEventsSet =
+      new Set(Array.isArray(excludeEvents) ? excludeEvents : []);
+    this._includeSchemaMap = compileSchemaFilter(includeSchema);
+    this._excludeSchemaMap = compileSchemaFilter(excludeSchema) || new Map();
   }
 
   get(name) {
@@ -289,6 +343,22 @@ class ZongJi extends EventEmitter {
       return;
     }
 
+    // A duplicate start() while one is already initialising is ignored;
+    // the first call completes. But if stop() intervened, this start()
+    // must proceed as a restart: the epoch below makes the stale
+    // initialisation chain abort, so exactly one binlog dump command is
+    // ever enqueued.
+    if (this._starting && !this.stopped) {
+      return;
+    }
+    this._starting = true;
+    this._startEpoch += 1;
+    const epoch = this._startEpoch;
+
+    // A resumed stream must not attribute early events to a GTID seen
+    // before the restart
+    this._currentGtid = undefined;
+
     this.stopped = false;
 
     if (!this.connection || !this.ctrlConnection) {
@@ -330,6 +400,16 @@ class ZongJi extends EventEmitter {
       });
     };
 
+    // Attach the current transaction's GTID (tracked at the packet layer,
+    // even when 'gtid' events are filtered out). Gtid/AnonymousGtid events
+    // keep their own parsed value.
+    const attachGtid = (event) => {
+      if (!('gtid' in event)) {
+        event.gtid = this._currentGtid;
+      }
+      return event;
+    };
+
     const binlogHandler = (error, event) => {
       if (error) {
         return this.emit('error', error);
@@ -347,6 +427,7 @@ class ZongJi extends EventEmitter {
           if (!tableMap || tableMap.tableName !== event.tableName || tableMap.columns.length !== event.columnCount) {
             if (!this.connection) return;
             this.connection.pause();
+            attachGtid(event);
             this._fetchTableInfo(event, () => {
               // merge the column info with metadata
               event.updateColumnInfo();
@@ -364,7 +445,7 @@ class ZongJi extends EventEmitter {
           break;
       }
       this.options.position = event.nextPosition;
-      this.emit('binlog', event);
+      this.emit('binlog', attachGtid(event));
     };
 
     let promises = [new Promise(testChecksum)];
@@ -375,7 +456,13 @@ class ZongJi extends EventEmitter {
 
     Promise.all(promises)
       .then(() => {
-        // Check if stop() was called while promises were pending
+        // Abort if a newer start() superseded this one (after a stop())
+        // while promises were pending
+        if (epoch !== this._startEpoch) {
+          return;
+        }
+        this._starting = false;
+        // Abort if stop() was called while promises were pending
         if (this.stopped) {
           return;
         }
@@ -384,8 +471,9 @@ class ZongJi extends EventEmitter {
         this.ready = true;
         this.emit('ready');
 
-        // Final check right before addCommand - connection may have been destroyed
-        if (this.stopped) {
+        // Final check right before addCommand - connection may have been
+        // destroyed or this start() superseded by a ready handler
+        if (this.stopped || epoch !== this._startEpoch) {
           return;
         }
 
@@ -413,6 +501,10 @@ class ZongJi extends EventEmitter {
         this.connection.addCommand(new this.BinlogClass(binlogHandler));
       })
       .catch(err => {
+        if (epoch !== this._startEpoch) {
+          return;
+        }
+        this._starting = false;
         this.emit('error', err);
       });
 
@@ -427,10 +519,25 @@ class ZongJi extends EventEmitter {
       return;
     }
 
+    // Errors emitted by a connection we are deliberately destroying are
+    // teardown noise (e.g. in-flight queries failing with
+    // ERR_STREAM_WRITE_AFTER_END); do not forward them to the caller
+    const silenceErrors = (conn) => {
+      conn.removeAllListeners('error');
+      conn.on('error', () => {});
+    };
+
+    // Capture the connections this stop() owns: finish() may fire from an
+    // async callback after a subsequent start() has already created
+    // replacement connections, and must not touch those
+    const ctrlConnection = this.ctrlConnection;
+    const ctrlToClose = this.ctrlConnectionOwner ? ctrlConnection : null;
+
     // Binary log connection does not end with destroy()
     let connectionThreadId = null;
     if (this.connection) {
       connectionThreadId = this.connection.threadId;
+      silenceErrors(this.connection);
       this.connection.destroy();
       // @ts-ignore - internal mysql2 API
       if (this.connection.stream && typeof this.connection.stream.unref === 'function') {
@@ -443,24 +550,29 @@ class ZongJi extends EventEmitter {
     const finish = () => {
       if (finished) return;
       finished = true;
-      if (this.ctrlConnectionOwner && this.ctrlConnection) {
-        this.ctrlConnection.destroy();
+      if (ctrlToClose) {
+        silenceErrors(ctrlToClose);
+        ctrlToClose.destroy();
         // @ts-ignore - internal mysql2 API
-        if (this.ctrlConnection.stream && typeof this.ctrlConnection.stream.unref === 'function') {
+        if (ctrlToClose.stream && typeof ctrlToClose.stream.unref === 'function') {
           // @ts-ignore - internal mysql2 API
-          this.ctrlConnection.stream.unref();
+          ctrlToClose.stream.unref();
+        }
+        if (this.ctrlConnection === ctrlToClose) {
+          this.ctrlConnection = null;
         }
-        this.ctrlConnection = null;
       }
       this.emit('stopped');
     };
 
-    if (!this.ctrlConnection ||
-        this.ctrlConnection.state === 'disconnected' ||
-        this.ctrlConnection._fatalError ||
-        this.ctrlConnection._protocolError ||
-        this.ctrlConnection._closing) {
-      this.ctrlConnection = null;
+    if (!ctrlConnection ||
+        ctrlConnection.state === 'disconnected' ||
+        ctrlConnection._fatalError ||
+        ctrlConnection._protocolError ||
+        ctrlConnection._closing) {
+      if (this.ctrlConnection === ctrlConnection) {
+        this.ctrlConnection = null;
+      }
       return finish();
     }
 
@@ -470,7 +582,7 @@ class ZongJi extends EventEmitter {
 
     const killTimeout = setTimeout(finish, 1000);
     try {
-      this.ctrlConnection.query(
+      ctrlConnection.query(
         'KILL ' + connectionThreadId,
         () => {
           clearTimeout(killTimeout);
@@ -483,44 +595,40 @@ class ZongJi extends EventEmitter {
     }
   }
 
+  // Emit an error the first time an undecodable event type arrives so that
+  // dropped row changes (e.g. compressed transactions) are never silent.
+  _warnUnsupportedEvent(EventClass) {
+    if (this._warnedUnsupported.has(EventClass.name)) {
+      return;
+    }
+    this._warnedUnsupported.add(EventClass.name);
+    this.emit('error', new Error(EventClass.unsupportedReason));
+  }
+
   // It includes every events by default.
   _skipEvent(name) {
-    const includes = this.filters.includeEvents;
-    const excludes = this.filters.excludeEvents;
-
-    let included = (includes === undefined) ||
-      (Array.isArray(includes) && (includes.indexOf(name) > -1));
-    let excluded = Array.isArray(excludes) && (excludes.indexOf(name) > -1);
-
-    return excluded || !included;
+    if (this._excludeEventsSet.has(name)) {
+      return true;
+    }
+    return this._includeEventsSet !== undefined &&
+      !this._includeEventsSet.has(name);
   }
 
   // It doesn't skip any schema by default.
   _skipSchema(database, table) {
-    const includes = this.filters.includeSchema;
-    const excludes = this.filters.excludeSchema || {};
-
-    let included = (includes === undefined) ||
-      (
-        (database in includes) &&
-        (
-          includes[database] === true ||
-          (
-            Array.isArray(includes[database]) &&
-            includes[database].indexOf(table) > -1
-          )
-        )
-      );
-    let excluded = (database in excludes) &&
-      (
-        excludes[database] === true ||
-        (
-          Array.isArray(excludes[database]) &&
-          excludes[database].indexOf(table) > -1
-        )
-      );
+    const excludeEntry = this._excludeSchemaMap.get(database);
+    if (excludeEntry === true ||
+        (excludeEntry instanceof Set && excludeEntry.has(table))) {
+      return true;
+    }
 
-    return excluded || !included;
+    if (this._includeSchemaMap === undefined) {
+      return false;
+    }
+    const includeEntry = this._includeSchemaMap.get(database);
+    const included = includeEntry === true ||
+      (includeEntry instanceof Set && includeEntry.has(table));
+    return !included;
   }
 }
 

package/lib/binlog_event.js

@@ -364,6 +364,43 @@ class Unknown extends BinlogEvent {
   }
 }
 
+/* MySQL 8.0.20+ wraps whole transactions in a single compressed event when
+ * binlog_transaction_compression=ON. The embedded row events are
+ * zstd-compressed and zongji cannot decode them, so the row changes they
+ * carry would be silently lost. The first occurrence emits an error via
+ * ZongJi#_warnUnsupportedEvent (see unsupportedReason below).
+ */
+class TransactionPayload extends BinlogEvent {
+  constructor(parser, options, zongji) {
+    super(parser, options);
+    skipEventRemainder(parser, zongji);
+  }
+
+  static unsupportedReason =
+    'Server sent a TRANSACTION_PAYLOAD_EVENT (binlog_transaction_compression=ON). ' +
+    'zongji cannot decode compressed transactions, so their row events are NOT ' +
+    'being emitted. Set binlog_transaction_compression=OFF on the server to ' +
+    'receive these changes.';
+}
+
+/* MySQL 8.0+ emits partial JSON row updates when
+ * binlog_row_value_options=PARTIAL_JSON. The JSON diff format is not
+ * decodable by zongji, so these updates would be silently lost. The first
+ * occurrence emits an error via ZongJi#_warnUnsupportedEvent.
+ */
+class PartialUpdateRows extends BinlogEvent {
+  constructor(parser, options, zongji) {
+    super(parser, options);
+    skipEventRemainder(parser, zongji);
+  }
+
+  static unsupportedReason =
+    'Server sent a PARTIAL_UPDATE_ROWS_EVENT (binlog_row_value_options=PARTIAL_JSON). ' +
+    'zongji cannot decode partial JSON updates, so these UPDATE row events are ' +
+    'NOT being emitted. Clear binlog_row_value_options on the server to receive ' +
+    'these changes.';
+}
+
 export {
   BinlogEvent,
   Rotate,
@@ -375,5 +412,7 @@ export {
   Gtid,
   AnonymousGtid,
   PreviousGtids,
+  TransactionPayload,
+  PartialUpdateRows,
   Unknown
 };

package/lib/code_map.js

@@ -37,7 +37,13 @@ const CodeEvent = [
   'DELETE_ROWS_EVENT_V2',
   'GTID_LOG_EVENT',
   'ANONYMOUS_GTID_LOG_EVENT',
-  'PREVIOUS_GTIDS_LOG_EVENT'
+  'PREVIOUS_GTIDS_LOG_EVENT',
+  'TRANSACTION_CONTEXT_EVENT',
+  'VIEW_CHANGE_EVENT',
+  'XA_PREPARE_LOG_EVENT',
+  'PARTIAL_UPDATE_ROWS_EVENT',
+  'TRANSACTION_PAYLOAD_EVENT',
+  'HEARTBEAT_LOG_EVENT_V2'
 ];
 
 const EventClass = {
@@ -50,6 +56,8 @@ const EventClass = {
   GTID_LOG_EVENT: events.Gtid,
   ANONYMOUS_GTID_LOG_EVENT: events.AnonymousGtid,
   PREVIOUS_GTIDS_LOG_EVENT: events.PreviousGtids,
+  TRANSACTION_PAYLOAD_EVENT: events.TransactionPayload,
+  PARTIAL_UPDATE_ROWS_EVENT: events.PartialUpdateRows,
 
   TABLE_MAP_EVENT: events.TableMap,
   DELETE_ROWS_EVENT_V1: rowsEvents.DeleteRows,

package/lib/common.js

@@ -1,7 +1,6 @@
 import iconv from 'iconv-lite';
-import decodeJson from './json_decode.js';
+import decodeJson, { convertBigInts, jsonToText } from './json_decode.js';
 import * as dtDecode from './datetime_decode.js';
-import bigInt from 'big-integer';
 
 export const MysqlTypes = {
   DECIMAL: 0,
@@ -40,7 +39,27 @@ export const MysqlTypes = {
 };
 
 const TWO_TO_POWER_THIRTY_TWO = Math.pow(2, 32);
-const TWO_TO_POWER_SIXTY_THREE = '9223372036854775808'; // Math.pow(2, 63) or 1 << 63
+const TWO_TO_POWER_SIXTY_THREE = 2n ** 63n;
+const TWO_TO_POWER_SIXTY_FOUR = 2n ** 64n;
+const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+
+// Combine two unsigned 32-bit halves into an exact unsigned 64-bit value.
+// Returns a Number when at or below 2^53 - 1, otherwise an exact string.
+export function unsignedInt64ToNumberOrString(high, low) {
+  const value = (BigInt(high) << 32n) | BigInt(low);
+  return value <= MAX_SAFE_BIGINT ? Number(value) : value.toString();
+}
+
+// Combine two unsigned 32-bit halves into an exact signed (two's
+// complement) 64-bit value. Returns a Number when within the safe integer
+// range, otherwise an exact string.
+export function signedInt64ToNumberOrString(high, low) {
+  const value = BigInt.asIntN(64, (BigInt(high) << 32n) | BigInt(low));
+  return (value >= MIN_SAFE_BIGINT && value <= MAX_SAFE_BIGINT) ?
+    Number(value) : value.toString();
+}
+
 // This function will return a Number
 // if the result < Math.MAX_SAFE_INTEGER or result > Math.MIN_SAFE_INTEGER,
 // otherwise, will return a string.
@@ -48,11 +67,11 @@ export const parseUInt64 = function(parser) {
   const low = parser.parseUnsignedNumber(4);
   const high = parser.parseUnsignedNumber(4);
 
-  if (high >>> 21) { // using bigint here
-    return bigInt(TWO_TO_POWER_THIRTY_TWO).multiply(high).add(low).toString();
+  if (high >>> 21) { // value is 2^53 or more, exceeds safe Number range
+    return unsignedInt64ToNumberOrString(high, low);
   }
 
-  return (high * Math.pow(2,32)) + low;
+  return (high * TWO_TO_POWER_THIRTY_TWO) + low;
 };
 
 export function parseUInt48(parser) {
@@ -115,12 +134,6 @@ export const parseIEEE754Float = function(high, low) {
   }
 };
 
-export function getUInt32Value(input) {
-  // Last bit is not sign, it is part of value!
-  if (input & (1 << 31)) return Math.pow(2, 31) + (input & ((1 << 31) -1));
-  else return input;
-};
-
 const parseAnyInt = function(parser, column, columnSchema) {
   let result, size;
   switch (column.type) {
@@ -151,16 +164,13 @@ const parseAnyInt = function(parser, column, columnSchema) {
     // Flip bits on negative signed integer
     if (!int64 && (result & (1 << (length - 1)))) {
       result = ((result ^ (Math.pow(2, length) - 1)) * -1) - 1;
-    } else if (int64 && bigInt(result).greaterOrEquals(bigInt(TWO_TO_POWER_SIXTY_THREE))) {
-      const Max64BitNumber = bigInt('18446744073709551615'); // 2^64 - 1
-      result = bigInt(result).xor(Max64BitNumber).add(1).multiply(-1);
-      // Javascript integers only support 2^53, if not within the range, return a String
-      if (result.greater(Number.MAX_SAFE_INTEGER) || result.lesser(Number.MIN_SAFE_INTEGER)) {
-        result = result.toString();
-      }
-      // Otherwise return a Number
-      else {
-        result = result.toJSNumber();
+    } else if (int64) {
+      const unsigned = BigInt(result);
+      if (unsigned >= TWO_TO_POWER_SIXTY_THREE) {
+        const signed = unsigned - TWO_TO_POWER_SIXTY_FOUR;
+        // Javascript Numbers only cover +-(2^53 - 1); return an exact
+        // string outside that range
+        result = signed >= MIN_SAFE_BIGINT ? Number(signed) : signed.toString();
       }
     }
   }
@@ -185,7 +195,11 @@ const readIntBE = function(buf, offset, length, noAssert) {
 // https://github.com/jeremycole/mysql_binlog/blob/master/lib/mysql_binlog/binlog_field_parser.rb
 // Some more information about DECIMAL types:
 // http://dev.mysql.com/doc/refman/5.5/en/precision-math-decimal-characteristics.html
-const parseNewDecimal = function(parser, column) {
+// Returns the exact decimal value as a string (matching mysql2's default
+// treatment of DECIMAL columns), or as a Number if the connection was
+// configured with the mysql2 `decimalNumbers` option (which may lose
+// precision beyond 15 significant digits).
+const parseNewDecimal = function(parser, column, zongji) {
   // Constants of format
   const digitsPerInteger = 9;
   const compressedBytes = [0, 1, 1, 2, 2, 3, 3, 4, 4, 4];
@@ -197,38 +211,37 @@ const parseNewDecimal = function(parser, column) {
   const compIntegral = integral - (uncompIntegral * digitsPerInteger);
   const compFractional = scale - (uncompFractional * digitsPerInteger);
 
-  // Grab buffer portion
+  // Copy buffer portion: the sign bit is flipped in place below and the
+  // underlying packet buffer must not be mutated
   const size = (uncompIntegral * 4) + compressedBytes[compIntegral] +
              (uncompFractional * 4) + compressedBytes[compFractional];
-  const buffer = parser._buffer.slice(parser._offset, parser._offset + size);
+  const buffer = Buffer.from(
+    parser._buffer.subarray(parser._offset, parser._offset + size));
   parser._offset += size; // Move binlog parser position forward
 
-  let str, mask;
   let pos = 0;
   const isPositive = (buffer.readUInt8(0) & (1 << 7)) === 128;
   buffer.writeUInt8(buffer.readUInt8(0) ^ (1 << 7), 0);
-  if (isPositive) {
-    // Positive number
-    str = '';
-    mask = 0;
-  } else {
-    // Negative number
-    str = '-';
-    mask = -1;
-  }
+  // Negative numbers are stored with all bits flipped
+  const mask = isPositive ? 0 : -1;
 
   // Build integer digits
+  let intDigits = '';
   const compIntegralSize = compressedBytes[compIntegral];
   if (compIntegralSize > 0) {
-    str += (readIntBE(buffer, 0, compIntegralSize) ^ mask).toString(10);
+    intDigits += (readIntBE(buffer, 0, compIntegralSize) ^ mask).toString(10);
     pos += compIntegralSize;
   }
 
   for (let i = 0; i < uncompIntegral; i++) {
-    str += zeroPad((buffer.readInt32BE(pos) ^ mask).toString(10), 9);
+    intDigits += zeroPad((buffer.readInt32BE(pos) ^ mask).toString(10), 9);
     pos += 4;
   }
 
+  // Strip leading zeros, keeping at least one digit
+  intDigits = intDigits.replace(/^0+(?=\d)/, '');
+  if (intDigits === '') intDigits = '0';
+
   // Build fractional digits
   let fractionDigits = '';
 
@@ -242,10 +255,13 @@ const parseNewDecimal = function(parser, column) {
     fractionDigits += zeroPad((readIntBE(buffer, pos, compFractionalSize) ^ mask).toString(10), compFractional);
   }
 
-  // Fractional digits may have leading zeros
-  str += '.' + fractionDigits;
+  let str = (isPositive ? '' : '-') + intDigits;
+  if (scale > 0) {
+    str += '.' + fractionDigits;
+  }
 
-  return parseFloat(str);
+  const config = zongji && zongji.connection && zongji.connection.config;
+  return config && config.decimalNumbers ? parseFloat(str) : str;
 };
 
 // Did not work in place. Function cribbed from lines 311-363 of
@@ -380,7 +396,7 @@ export function readMysqlValue(
       result = parseIEEE754Float(high, low);
       break;
     case MysqlTypes.NEWDECIMAL:
-      result = parseNewDecimal(parser, column);
+      result = parseNewDecimal(parser, column, zongji);
       break;
     case MysqlTypes.SET:
       if (column.metadata.size === 8) {
@@ -454,12 +470,24 @@ export function readMysqlValue(
         }
       }
       break;
-    case MysqlTypes.JSON:
+    case MysqlTypes.JSON: {
       lengthSize = column.metadata['length_size'];
       size = parser.parseUnsignedNumber(lengthSize);
       buffer = parser.parseBuffer(size);
-      result = buffer.length === 0 ? null : decodeJson(buffer);
+      if (buffer.length === 0) {
+        result = null;
+      } else {
+        // Match mysql2 semantics: parsed JavaScript value by default,
+        // raw JSON text with the jsonStrings connection option. 64-bit
+        // integers stay exact: raw numerals in text mode, Numbers within
+        // the safe range (exact strings beyond it) in parsed mode.
+        const decoded = decodeJson(buffer);
+        const config = zongji && zongji.connection && zongji.connection.config;
+        result = config && config.jsonStrings ?
+          jsonToText(decoded) : convertBigInts(decoded);
+      }
       break;
+    }
     case MysqlTypes.GEOMETRY:
       lengthSize = column.metadata['length_size'];
       size = parser.parseUnsignedNumber(lengthSize);