Initial work on the server

node_modules/mysql/benchmark/analyze.js

@@ -0,0 +1,96 @@
+var script = process.cwd() + '/' + process.argv[2];
+var spawn  = require('child_process').spawn;
+
+var numbers       = [];
+var boringResults = 0;
+var scriptRuns    = 0;
+
+function runScript() {
+  scriptRuns++;
+
+  var child = spawn(process.execPath, [script]);
+
+  var buffer = '';
+  child.stdout.on('data', function(chunk) {
+    buffer += chunk;
+
+    var offset;
+    while ((offset = buffer.indexOf('\n')) > -1) {
+      var number = parseInt(buffer.substr(0, offset), 10);
+      buffer = buffer.substr(offset + 1);
+
+      var maxBefore = max();
+      var minBefore = min();
+
+      numbers.push(number);
+
+      if (maxBefore === max() && minBefore === min()) {
+        boringResults++;
+      }
+
+      if (boringResults > 10) {
+        boringResults = 0;
+        child.kill();
+        runScript();
+      }
+    }
+  });
+}
+
+function report() {
+  console.log(
+    'max: %s | median: %s | sdev: %s | last: %s | min: %s | runs: %s | results: %s',
+    max(),
+    median(),
+    sdev(),
+    numbers[numbers.length - 1],
+    min(),
+    scriptRuns,
+    numbers.length
+  );
+}
+
+function min() {
+  if (!numbers.length) return undefined;
+
+  return numbers.reduce(function(min, number) {
+    return (number < min)
+      ? number
+      : min;
+  });
+}
+
+function max() {
+  if (!numbers.length) return undefined;
+
+  return numbers.reduce(function(max, number) {
+    return (number > max)
+      ? number
+      : max;
+  });
+}
+
+function median() {
+  return numbers[Math.floor(numbers.length / 2)];
+}
+
+function sdev() {
+  if (!numbers.length) return undefined;
+
+  return Math.round(Math.sqrt(variance()));
+}
+
+function variance() {
+  var t = 0, squares = 0, len = numbers.length;
+
+  for (var i=0; i<len; i++) {
+    var obs = numbers[i];
+    t += obs;
+    squares += Math.pow(obs, 2);
+  }
+  return (squares/len) - Math.pow(t/len, 2);
+}
+
+setInterval(report, 1000);
+
+runScript();

node_modules/mysql/benchmark/parse-100k-blog-rows.js

@@ -0,0 +1,112 @@
+var lib          = __dirname + '/../lib';
+var Protocol     = require(lib + '/protocol/protocol');
+var Packets      = require(lib + '/protocol/packets');
+var PacketWriter = require(lib + '/protocol/PacketWriter');
+var Parser       = require(lib + '/protocol/Parser');
+
+var options = {
+  rows       : 100000,
+  bufferSize : 64 * 1024,
+};
+
+console.error('Config:', options);
+
+function createBuffers() {
+  var parser = new Parser();
+
+  process.stderr.write('Creating row buffers ... ');
+
+  var number = 1;
+  var id     = 0;
+  var start  = Date.now();
+
+  var buffers = [
+    createPacketBuffer(parser, new Packets.ResultSetHeaderPacket({fieldCount: 2})),
+    createPacketBuffer(parser, new Packets.FieldPacket({catalog: 'foo', name: 'id'})),
+    createPacketBuffer(parser, new Packets.FieldPacket({catalog: 'foo', name: 'text'})),
+    createPacketBuffer(parser, new Packets.EofPacket()),
+  ];
+
+  for (var i = 0; i < options.rows; i++) {
+    buffers.push(createRowDataPacketBuffer(parser, number++));
+  }
+
+  buffers.push(createPacketBuffer(parser, new Packets.EofPacket));
+
+  buffers = mergeBuffers(buffers);
+
+  var bytes = buffers.reduce(function(bytes, buffer) {
+    return bytes + buffer.length;
+  }, 0);
+
+  var mb = (bytes / 1024 / 1024).toFixed(2)
+
+  console.error('%s buffers (%s mb) in %s ms', buffers.length, mb, (Date.now() - start));
+
+  return buffers;
+}
+
+function createPacketBuffer(parser, packet) {
+  var writer = new PacketWriter();
+  packet.write(writer);
+  return writer.toBuffer(parser);
+}
+
+function createRowDataPacketBuffer(parser, number) {
+  var writer = new PacketWriter();
+
+  writer.writeLengthCodedString(parser._nextPacketNumber);
+  writer.writeLengthCodedString('Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry\'s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has sur');
+
+  return writer.toBuffer(parser);
+}
+
+function mergeBuffers(buffers) {
+  var mergeBuffer  = new Buffer(options.bufferSize);
+  var mergeBuffers = [];
+  var offset       = 0;
+
+  for (var i = 0; i < buffers.length; i++) {
+    var buffer = buffers[i];
+
+    var bytesRemaining = mergeBuffer.length - offset;
+    if (buffer.length < bytesRemaining) {
+      buffer.copy(mergeBuffer, offset);
+      offset += buffer.length;
+    } else {
+      buffer.copy(mergeBuffer, offset, 0, bytesRemaining);
+      mergeBuffers.push(mergeBuffer);
+
+      mergeBuffer = new Buffer(options.bufferSize);
+      buffer.copy(mergeBuffer, 0, bytesRemaining);
+      offset = buffer.length - bytesRemaining;
+    }
+  }
+
+  if (offset > 0) {
+    mergeBuffers.push(mergeBuffer.slice(0, offset));
+  }
+
+  return mergeBuffers;
+}
+
+function benchmark(buffers) {
+  var protocol = new Protocol();
+  protocol._handshakeInitializationPacket = true;
+  protocol.query({typeCast: false, sql: 'SELECT ...'});
+
+  var start = +new Date;
+
+  for (var i = 0; i < buffers.length; i++) {
+    protocol.write(buffers[i]);
+  }
+
+  var duration = Date.now() - start;
+  var hz = Math.round(options.rows / (duration / 1000));
+  console.log(hz);
+}
+
+var buffers = createBuffers();
+while (true) {
+  benchmark(buffers);
+}

node_modules/mysql/benchmark/select-100k-blog-rows.js

@@ -0,0 +1,42 @@
+var common     = require('../test/common');
+var client     = common.createConnection({typeCast: false});
+var rowsPerRun = 100000;
+
+client.connect(function(err) {
+  if (err) throw err;
+
+  client.query('USE node_mysql_test', function(err, results) {
+    if (err) throw err;
+
+    selectRows();
+  });
+});
+
+var firstSelect;
+var rowCount = 0;
+
+console.error('Benchmarking rows per second in hz:');
+
+function selectRows() {
+  firstSelect = firstSelect || Date.now();
+
+  client.query('SELECT * FROM posts', function(err, rows) {
+    if (err) throw err;
+
+    rowCount += rows.length;
+    if (rowCount < rowsPerRun) {
+      selectRows();
+      return;
+    }
+
+    var duration = (Date.now() - firstSelect) / 1000;
+    var hz = Math.round(rowCount / duration);
+
+    console.log(hz);
+
+    rowCount    = 0;
+    firstSelect = null;
+
+    selectRows();
+  });
+};