@vlasky/zongji 0.5.8 → 0.6.0

package/lib/reader.js

@@ -1,141 +1,247 @@
 // Constants for variable length encoded binary
-const NULL_COLUMN = 251;
-const UNSIGNED_CHAR_COLUMN = 251;
-const UNSIGNED_SHORT_COLUMN = 252;
-const UNSIGNED_INT24_COLUMN = 253;
-const UNSIGNED_INT64_COLUMN = 254;
-
-function BufferReader(buffer) {
-  this.buffer = buffer;
-  this.position = 0;
-}
+export const NULL_COLUMN = 251;
+export const UNSIGNED_CHAR_COLUMN = 251;
+export const UNSIGNED_SHORT_COLUMN = 252;
+export const UNSIGNED_INT24_COLUMN = 253;
+export const UNSIGNED_INT64_COLUMN = 254;
 
-BufferReader.prototype.readUInt8 = function() {
-  const pos = this.position;
-  this.position += 1;
+const padWith = function(val, length) {
+  const bits = val.split('');
+  if (bits.length < length) {
+    const left = length - bits.length;
+    for (let j = left - 1; j >= 0; j--) {
+      bits.unshift('0');
+    }
+    val = bits.join('');
+  }
 
-  return this.buffer.readUInt8(pos);
+  return val;
 };
 
-BufferReader.prototype.readUInt16 = function() {
-  const pos = this.position;
-  this.position += 2;
+class BufferReader {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.position = 0;
+  }
 
-  return this.buffer.readUInt16LE(pos);
-};
+  readUInt8() {
+    const pos = this.position;
+    this.position += 1;
 
-BufferReader.prototype.readUInt32 = function() {
-  const pos = this.position;
-  this.position += 4;
+    return this.buffer.readUInt8(pos);
+  }
 
-  return this.buffer.readUInt32LE(pos);
-};
+  readUInt16() {
+    const pos = this.position;
+    this.position += 2;
 
-BufferReader.prototype.readUInt24 = function() {
-  const low = this.readUInt16();
-  const high = this.readUInt8();
-  return (high << 16) + low;
-};
+    return this.buffer.readUInt16LE(pos);
+  }
 
-BufferReader.prototype.readUInt64 = function() {
-  const pos = this.position;
-  this.position += 8;
+  readUInt32() {
+    const pos = this.position;
+    this.position += 4;
 
-  // from http://stackoverflow.com/questions/17687307/convert-a-64bit-little-endian-integer-to-number
-  return this.buffer.readInt32LE(pos) +
-    0x100000000 * this.buffer.readUInt32LE(pos + 4);
-};
+    return this.buffer.readUInt32LE(pos);
+  }
 
-BufferReader.prototype.readString = function() {
-  const strBuf = this.buffer.slice(this.position);
-  this.position = this.buffer.length;
+  readUInt24() {
+    const low = this.readUInt16();
+    const high = this.readUInt8();
+    return (high << 16) + low;
+  }
 
-  return strBuf.toString('ascii');
-};
+  readUInt64() {
+    const pos = this.position;
+    this.position += 8;
 
-BufferReader.prototype.readStringInBytes = function(length) {
-  const strBuf = this.buffer.slice(this.position, this.position + length);
-  this.position += length;
+    // from http://stackoverflow.com/questions/17687307/convert-a-64bit-little-endian-integer-to-number
+    return this.buffer.readInt32LE(pos) +
+      0x100000000 * this.buffer.readUInt32LE(pos + 4);
+  }
 
-  return strBuf.toString('ascii');
-};
+  readString() {
+    const strBuf = this.buffer.slice(this.position);
+    this.position = this.buffer.length;
 
-BufferReader.prototype.readHexInBytes = function(length) {
-  const buf = this.buffer.slice(this.position, this.position + length);
-  this.position += length;
+    return strBuf.toString('ascii');
+  }
 
-  return buf.toString('hex');
-};
+  readStringInBytes(length) {
+    const strBuf = this.buffer.slice(this.position, this.position + length);
+    this.position += length;
 
-BufferReader.prototype.readBytesArray = function(length) {
-  const result = [];
-  const hexString = this.readHexInBytes(length);
-  for (let i = 0; i < hexString.length; i = i + 2) {
-    result.push(parseInt(hexString.substr(i, 2), 16));
+    return strBuf.toString('ascii');
   }
-  return result;
-};
 
-// Read a variable-length "Length Coded Binary" integer. This is derived
-// from the MySQL protocol, and re-used in the binary log format. This
-// format uses the first byte to alternately store the actual value for
-// integer values <= 250, or to encode the number of following bytes
-// used to store the actual value, which can be 2, 3, or 8. It also
-// includes support for SQL NULL as a special case.
-BufferReader.prototype.readVariant = function() {
-  let result = null;
-  const firstByte = this.readUInt8();
-
-  if (firstByte < UNSIGNED_CHAR_COLUMN) {
-    result = firstByte;
-  } else if (firstByte === NULL_COLUMN) {
-    result = null;
-  } else if (firstByte === UNSIGNED_SHORT_COLUMN) {
-    result = this.readUInt16();
-  } else if (firstByte === UNSIGNED_INT24_COLUMN) {
-    result = this.readUInt24();
-  } else if (firstByte === UNSIGNED_INT64_COLUMN) {
-    result = this.readUInt64();
-  } else {
-    throw new Error('Invalid variable-length integer');
-  }
-
-  return result;
-};
+  readHexInBytes(length) {
+    const buf = this.buffer.slice(this.position, this.position + length);
+    this.position += length;
 
-const padWith = function(val, length) {
-  const bits = val.split('');
-  if (bits.length < length) {
-    const left = length - bits.length;
-    for (let j = left - 1; j >= 0; j--) {
-      bits.unshift('0');
+    return buf.toString('hex');
+  }
+
+  readBytesArray(length) {
+    const result = [];
+    const hexString = this.readHexInBytes(length);
+    for (let i = 0; i < hexString.length; i = i + 2) {
+      result.push(parseInt(hexString.substr(i, 2), 16));
     }
-    val = bits.join('');
+    return result;
   }
 
-  return val;
-};
+  // Read a variable-length "Length Coded Binary" integer. This is derived
+  // from the MySQL protocol, and re-used in the binary log format. This
+  // format uses the first byte to alternately store the actual value for
+  // integer values <= 250, or to encode the number of following bytes
+  // used to store the actual value, which can be 2, 3, or 8. It also
+  // includes support for SQL NULL as a special case.
+  readVariant() {
+    let result = null;
+    const firstByte = this.readUInt8();
+
+    if (firstByte < UNSIGNED_CHAR_COLUMN) {
+      result = firstByte;
+    } else if (firstByte === NULL_COLUMN) {
+      result = null;
+    } else if (firstByte === UNSIGNED_SHORT_COLUMN) {
+      result = this.readUInt16();
+    } else if (firstByte === UNSIGNED_INT24_COLUMN) {
+      result = this.readUInt24();
+    } else if (firstByte === UNSIGNED_INT64_COLUMN) {
+      result = this.readUInt64();
+    } else {
+      throw new Error('Invalid variable-length integer');
+    }
 
-// Read an arbitrary-length bitmap, provided its length.
-// Returns an array of true/false values.
-BufferReader.prototype.readBitArray = function(length) {
-  const size = Math.floor((length + 7) / 8);
+    return result;
+  }
 
-  const bytes = [];
-  for (let i = size - 1; i >= 0; i--) {
-    bytes.unshift(this.readUInt8());
+  // Read an arbitrary-length bitmap, provided its length.
+  // Returns an array of true/false values.
+  readBitArray(length) {
+    const size = Math.floor((length + 7) / 8);
+
+    const bytes = [];
+    for (let i = size - 1; i >= 0; i--) {
+      bytes.unshift(this.readUInt8());
+    }
+
+    const bitmap = [];
+    const bitmapStr = bytes.map(function(aByte) {
+      return padWith(aByte.toString(2), 8);
+    }).join('');
+
+    for (let k = bitmapStr.length - 1; k >= 0; k--) {
+      bitmap.push(bitmapStr[k] === '1');
+    }
+
+    return bitmap.slice(0, length);
   }
+}
 
-  const bitmap = [];
-  const bitmapStr = bytes.map(function(aByte) {
-    return padWith(aByte.toString(2), 8);
-  }).join('');
+class Parser {
+  constructor(packet) {
+    this.packet = null;
+    this._buffer = null;
+    this._offsetValue = 0;
+    this._packetEndValue = 0;
 
-  for (let k = bitmapStr.length - 1; k >= 0; k--) {
-    bitmap.push(bitmapStr[k] === '1');
+    if (packet) {
+      this.setPacket(packet);
+    }
   }
 
-  return bitmap.slice(0, length);
-};
+  get _offset() {
+    return this.packet ? this.packet.offset : this._offsetValue;
+  }
+
+  set _offset(value) {
+    if (this.packet) {
+      this.packet.offset = value;
+    } else {
+      this._offsetValue = value;
+    }
+  }
+
+  get _packetEnd() {
+    return this.packet ? this.packet.end : this._packetEndValue;
+  }
+
+  set _packetEnd(value) {
+    if (this.packet) {
+      this.packet.end = value;
+    } else {
+      this._packetEndValue = value;
+    }
+  }
+
+  setPacket(packet) {
+    this.packet = packet;
+    this._buffer = packet.buffer;
+  }
+
+  append(buffer) {
+    this.packet = null;
+    this._buffer = buffer;
+    this._offsetValue = 0;
+    this._packetEndValue = buffer.length;
+  }
+
+  parseUnsignedNumber(bytes) {
+    const offset = this._offset;
+    this._offset += bytes;
+
+    if (bytes <= 6) {
+      return this._buffer.readUIntLE(offset, bytes);
+    }
+
+    if (bytes === 8) {
+      const low = this._buffer.readUInt32LE(offset);
+      const high = this._buffer.readUInt32LE(offset + 4);
+      return (high * 0x100000000) + low;
+    }
+
+    throw new Error('Invalid unsigned integer size: ' + bytes);
+  }
+
+  parseLengthCodedNumber() {
+    const first = this.parseUnsignedNumber(1);
+    if (first < 251) return first;
+    if (first === 251) return null;
+    if (first === 252) return this.parseUnsignedNumber(2);
+    if (first === 253) return this.parseUnsignedNumber(3);
+    if (first === 254) return this.parseUnsignedNumber(8);
+    throw new Error('Invalid length coded number');
+  }
+
+  parseBuffer(length) {
+    if (length === undefined) {
+      length = this._packetEnd - this._offset;
+    }
+    const start = this._offset;
+    this._offset += length;
+    return this._buffer.slice(start, start + length);
+  }
+
+  parseString(length) {
+    const buffer = this.parseBuffer(length);
+    return buffer.toString('utf8');
+  }
+
+  parsePacketTerminatedString() {
+    return this.parseString(this._packetEnd - this._offset);
+  }
+
+  parseLengthCodedString() {
+    const length = this.parseLengthCodedNumber();
+    if (length === null) return null;
+    return this.parseString(length);
+  }
+
+  reachedPacketEnd() {
+    return this._offset >= this._packetEnd;
+  }
+}
 
-exports.BufferReader = BufferReader;
+export { BufferReader, Parser };

package/lib/rows_event.js

@@ -1,6 +1,5 @@
-const util = require('util');
-const BinlogEvent = require('./binlog_event').BinlogEvent;
-const Common = require('./common');
+import { BinlogEvent } from './binlog_event.js';
+import * as Common from './common.js';
 
 const Version2Events = [
   0x1e, // WRITE_ROWS_EVENT_V2,
@@ -39,79 +38,80 @@ const BIT_COUNT_MAP_IN_ONE_BYTE = [
  *   zongji: ZongJi instance
  **/
 
-function RowsEvent(parser, options, zongji) {
-  BinlogEvent.apply(this, arguments);
-  this._zongji = zongji;
-  this._readTableId(parser);
-  this.flags = parser.parseUnsignedNumber(2);
-  this.useChecksum = zongji.useChecksum;
-
-  // Version 2 Events
-  if (Version2Events.indexOf(options.eventType) !== -1) {
-    this.extraDataLength = parser.parseUnsignedNumber(2);
-    // skip extra data
-    parser.parseBuffer(this.extraDataLength - 2);
-  }
-
-  // Body
-  this.numberOfColumns = parser.parseLengthCodedNumber();
-
-  this.tableMap = zongji.tableMap;
-
-  const tableData = this.tableMap[this.tableId];
-  if (tableData === undefined) {
-    // TableMap event was filtered
-    parser._offset = parser._packetEnd;
-    this._filtered = true;
-  } else {
-    const columnsPresentBitmapSize = Math.floor((this.numberOfColumns + 7) / 8);
-    this.columns_present_bitmap = parser.parseBuffer(columnsPresentBitmapSize);
-    if (this._hasTwoRows) {
-      // UpdateRows event slightly different, has new and old rows represented
-      this.columns_present_bitmap2 = parser.parseBuffer(columnsPresentBitmapSize);
+class RowsEvent extends BinlogEvent {
+  constructor(parser, options, zongji, hasTwoRows = false) {
+    super(parser, options);
+    this._zongji = zongji;
+    this._hasTwoRows = hasTwoRows;
+    this._readTableId(parser);
+    this.flags = parser.parseUnsignedNumber(2);
+    this.useChecksum = zongji.useChecksum;
+
+    // Version 2 Events
+    if (Version2Events.indexOf(options.eventType) !== -1) {
+      this.extraDataLength = parser.parseUnsignedNumber(2);
+      // skip extra data
+      parser.parseBuffer(this.extraDataLength - 2);
     }
 
-    if (this.useChecksum) {
-      // Ignore the checksum at the end of this packet
-      parser._packetEnd -= CHECKSUM_SIZE;
-    }
+    // Body
+    this.numberOfColumns = parser.parseLengthCodedNumber();
 
-    this.rows = [];
-    while (!parser.reachedPacketEnd()) {
-      this.rows.push(this._fetchOneRow(parser));
-    }
+    this.tableMap = zongji.tableMap;
 
-    if (this.useChecksum) {
-      // Skip past the checksum at the end of the packet
-      parser._packetEnd += CHECKSUM_SIZE;
-      parser._offset += CHECKSUM_SIZE;
+    const tableData = this.tableMap[this.tableId];
+    if (tableData === undefined) {
+      // TableMap event was filtered
+      parser._offset = parser._packetEnd;
+      this._filtered = true;
+    } else {
+      const columnsPresentBitmapSize = Math.floor((this.numberOfColumns + 7) / 8);
+      this.columns_present_bitmap = parser.parseBuffer(columnsPresentBitmapSize);
+      if (this._hasTwoRows) {
+        // UpdateRows event slightly different, has new and old rows represented
+        this.columns_present_bitmap2 = parser.parseBuffer(columnsPresentBitmapSize);
+      }
+
+      if (this.useChecksum) {
+        // Ignore the checksum at the end of this packet
+        parser._packetEnd -= CHECKSUM_SIZE;
+      }
+
+      this.rows = [];
+      while (!parser.reachedPacketEnd()) {
+        this.rows.push(this._fetchOneRow(parser));
+      }
+
+      if (this.useChecksum) {
+        // Skip past the checksum at the end of the packet
+        parser._packetEnd += CHECKSUM_SIZE;
+        parser._offset += CHECKSUM_SIZE;
+      }
     }
   }
-}
-
-util.inherits(RowsEvent, BinlogEvent);
 
-RowsEvent.prototype.setTableMap = function(tableMap) {
-  this.tableMap = tableMap;
-};
+  setTableMap(tableMap) {
+    this.tableMap = tableMap;
+  }
 
-RowsEvent.prototype.dump = function() {
-  BinlogEvent.prototype.dump.apply(this);
-  console.log('Affected columns:', this.numberOfColumns);
-  console.log('Changed rows:', this.rows.length);
-  console.log('Values:');
-  this.rows.forEach(function(row) {
-    console.log('--');
-    Object.keys(row).forEach(function(name) {
-      console.log('Column: %s, Value: %s', name, row[name]);
+  dump() {
+    super.dump();
+    console.log('Affected columns:', this.numberOfColumns);
+    console.log('Changed rows:', this.rows.length);
+    console.log('Values:');
+    this.rows.forEach(function(row) {
+      console.log('--');
+      Object.keys(row).forEach(function(name) {
+        console.log('Column: %s, Value: %s', name, row[name]);
+      });
     });
-  });
-};
+  }
 
-RowsEvent.prototype._fetchOneRow = function(parser) {
-  const tablemap = this.tableMap[this.tableId];
-  return readRow(parser, tablemap, this.columns_present_bitmap, this._zongji);
-};
+  _fetchOneRow(parser) {
+    const tablemap = this.tableMap[this.tableId];
+    return readRow(parser, tablemap, this.columns_present_bitmap, this._zongji);
+  }
+}
 
 const countBits = function(buff) {
   let bits = 0;
@@ -154,47 +154,43 @@ const readRow = function(parser, tablemap, bitmap, zongji) {
 };
 
 // Subclasses
-function WriteRows(parser, options) { // eslint-disable-line
-  RowsEvent.apply(this, arguments);
-}
-
-util.inherits(WriteRows, RowsEvent);
-
-// eslint
-function DeleteRows(parser, options) { // eslint-disable-line
-  RowsEvent.apply(this, arguments);
+class WriteRows extends RowsEvent {
+  constructor(parser, options, zongji) {
+    super(parser, options, zongji);
+  }
 }
 
-util.inherits(DeleteRows, RowsEvent);
-
-function UpdateRows(parser, options) { // eslint-disable-line
-  this._hasTwoRows = true;
-  RowsEvent.apply(this, arguments);
+class DeleteRows extends RowsEvent {
+  constructor(parser, options, zongji) {
+    super(parser, options, zongji);
+  }
 }
 
-util.inherits(UpdateRows, RowsEvent);
+class UpdateRows extends RowsEvent {
+  constructor(parser, options, zongji) {
+    super(parser, options, zongji, true);
+  }
 
-UpdateRows.prototype._fetchOneRow = function(parser) {
-  const tablemap = this.tableMap[this.tableId];
-  return {
-    before: readRow(parser, tablemap, this.columns_present_bitmap, this._zongji),
-    after: readRow(parser, tablemap, this.columns_present_bitmap2, this._zongji),
-  };
-};
+  _fetchOneRow(parser) {
+    const tablemap = this.tableMap[this.tableId];
+    return {
+      before: readRow(parser, tablemap, this.columns_present_bitmap, this._zongji),
+      after: readRow(parser, tablemap, this.columns_present_bitmap2, this._zongji),
+    };
+  }
 
-UpdateRows.prototype.dump = function() {
-  BinlogEvent.prototype.dump.apply(this);
-  console.log('Affected columns:', this.numberOfColumns);
-  console.log('Changed rows:', this.rows.length);
-  console.log('Values:');
-  this.rows.forEach(function(row) {
-    console.log('--');
-    Object.keys(row.before).forEach(function(name) {
-      console.log('Column: %s, Value: %s => %s', name, row.before[name], row.after[name]);
+  dump() {
+    BinlogEvent.prototype.dump.call(this);
+    console.log('Affected columns:', this.numberOfColumns);
+    console.log('Changed rows:', this.rows.length);
+    console.log('Values:');
+    this.rows.forEach(function(row) {
+      console.log('--');
+      Object.keys(row.before).forEach(function(name) {
+        console.log('Column: %s, Value: %s => %s', name, row.before[name], row.after[name]);
+      });
     });
-  });
-};
+  }
+}
 
-exports.WriteRows = WriteRows;
-exports.DeleteRows = DeleteRows;
-exports.UpdateRows = UpdateRows;
+export { WriteRows, DeleteRows, UpdateRows };