WIP compressed read

Author: dougwilson

Readme.md

@@ -1373,18 +1373,22 @@ The following flags are sent by default on a new connection:
 - `SECURE_CONNECTION` - Support native 4.1 authentication.
 - `TRANSACTIONS` - Asks for the transaction status flags.
 
-In addition, the following flag will be sent if the option `multipleStatements`
+The following flag will be sent if the option `multipleStatements`
 is set to `true`:
 
 - `MULTI_STATEMENTS` - The client may send multiple statement per query or
   statement prepare.
 
+The following flag will be sent if the option `compress` is set to `true`
+and the server indicates support for compression:
+
+- `COMPRESS` - Compress data between client and server.
+
 ### Other Available Flags
 
 There are other flags available. They may or may not function, but are still
 available to specify.
 
-- `COMPRESS`
 - `INTERACTIVE`
 - `NO_SCHEMA`
 - `PLUGIN_AUTH`

lib/ConnectionConfig.js

@@ -22,6 +22,7 @@ function ConnectionConfig(options) {
   this.insecureAuth       = options.insecureAuth || false;
   this.supportBigNumbers  = options.supportBigNumbers || false;
   this.bigNumberStrings   = options.bigNumberStrings || false;
+  this.compress           = options.compress || false;
   this.dateStrings        = options.dateStrings || false;
   this.debug              = options.debug;
   this.trace              = options.trace !== false;
@@ -95,7 +96,6 @@ ConnectionConfig.getCharsetNumber = function getCharsetNumber(charset) {
 
 ConnectionConfig.getDefaultFlags = function getDefaultFlags(options) {
   var defaultFlags = [
-    '-COMPRESS',          // Compression protocol *NOT* supported
     '-CONNECT_ATTRS',     // Does *NOT* send connection attributes in Protocol::HandshakeResponse41
     '+CONNECT_WITH_DB',   // One can specify db on connect in Handshake Response Packet
     '+FOUND_ROWS',        // Send found rows instead of affected rows

lib/protocol/BufferList.js

@@ -23,3 +23,12 @@ BufferList.prototype.push = function push(buf) {
   this.bufs.push(buf);
   this.size += buf.length;
 };
+
+BufferList.prototype.unshift = function unshift(buf) {
+  if (!buf || !buf.length) {
+    return;
+  }
+
+  this.bufs.unshift(buf);
+  this.size += buf.length;
+};

lib/protocol/CompressedPacketHeader.js

@@ -0,0 +1,31 @@
+module.exports = CompressedPacketHeader;
+function CompressedPacketHeader(options) {
+  options = options || {};
+
+  this.length   = options.length || 0;
+  this.sequence = options.sequence || 0;
+  this.size     = options.size || 0;
+}
+
+CompressedPacketHeader.fromBuffer = function fromBuffer(buffer) {
+  var length   = 0;
+  var offset   = 0;
+  var sequence = 0;
+  var size     = 0;
+
+  for (var i = 0; i < 3; i++) {
+    length |= buffer[offset++] << (i * 8);
+  }
+
+  sequence = buffer[offset++];
+
+  for (var i = 0; i < 3; i++) {
+    size |= buffer[offset++] << (i * 8);
+  }
+
+  return new CompressedPacketHeader({
+    length   : length,
+    sequence : sequence,
+    size     : size
+  });
+};

lib/protocol/PacketWriter.js

@@ -1,9 +1,11 @@
-var BIT_16            = Math.pow(2, 16);
-var BIT_24            = Math.pow(2, 24);
-var BUFFER_ALLOC_SIZE = Math.pow(2, 8);
+var BIT_16                          = Math.pow(2, 16);
+var BIT_24                          = Math.pow(2, 24);
+var BUFFER_ALLOC_SIZE               = Math.pow(2, 8);
+var COMPRESSED_PACKET_HEADER_LENGTH = 7;
 // The maximum precision JS Numbers can hold precisely
 // Don't panic: Good enough to represent byte values up to 8192 TB
 var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
+var PACKET_HEADER_LENGTH         = 4;
 var MAX_PACKET_LENGTH            = Math.pow(2, 24) - 1;
 var Buffer                       = require('safe-buffer').Buffer;
 
@@ -22,8 +24,9 @@ PacketWriter.prototype.toBuffer = function toBuffer(parser) {
   var buffer  = this._buffer;
   var length  = this._offset;
   var packets = Math.floor(length / MAX_PACKET_LENGTH) + 1;
+  var size    = length + (packets * PACKET_HEADER_LENGTH);
 
-  this._buffer = Buffer.allocUnsafe(length + packets * 4);
+  this._buffer = Buffer.allocUnsafe(size);
   this._offset = 0;
 
   for (var packet = 0; packet < packets; packet++) {
@@ -43,6 +46,34 @@ PacketWriter.prototype.toBuffer = function toBuffer(parser) {
     this.writeBuffer(buffer.slice(start, end));
   }
 
+  if (parser._compressed) {
+    buffer  = this._buffer;
+    length  = this._offset;
+    packets = Math.floor(length / MAX_PACKET_LENGTH) + 1;
+    size    = length + (packets * COMPRESSED_PACKET_HEADER_LENGTH);
+
+    this._buffer = Buffer.allocUnsafe(size);
+    this._offset = 0;
+
+    for (packet = 0; packet < packets; packet++) {
+      isLast = (packet + 1 === packets);
+      packetLength = (isLast)
+        ? length % MAX_PACKET_LENGTH
+        : MAX_PACKET_LENGTH;
+
+      packetNumber = parser.incrementCompressedPacketNumber();
+
+      this.writeUnsignedNumber(3, packetLength);
+      this.writeUnsignedNumber(1, packetNumber);
+      this.writeUnsignedNumber(3, 0);
+
+      var start = packet * MAX_PACKET_LENGTH;
+      var end   = start + packetLength;
+
+      this.writeBuffer(buffer.slice(start, end));
+    }
+  }
+
   return this._buffer;
 };