tedious 1.12.3 → 1.14.0

package/README.md

@@ -1,5 +1,5 @@
 # Tedious (node implementation of TDS)
-[![Dependency Status](https://david-dm.org/pekim/tedious.png)](https://david-dm.org/pekim/tedious) [![NPM version](https://badge.fury.io/js/tedious.png)](http://badge.fury.io/js/tedious) [![Build Status](https://secure.travis-ci.org/pekim/tedious.png)](http://travis-ci.org/pekim/tedious) [![Build Status](https://ci.appveyor.com/api/projects/status/ike3p58hljpyffrl?svg=true)](https://ci.appveyor.com/project/pekim/tedious)
+[![Dependency Status](https://david-dm.org/pekim/tedious.svg)](https://david-dm.org/pekim/tedious) [![NPM version](https://badge.fury.io/js/tedious.svg)](http://badge.fury.io/js/tedious) [![Build Status](https://secure.travis-ci.org/pekim/tedious.svg)](http://travis-ci.org/pekim/tedious) [![Build Status](https://ci.appveyor.com/api/projects/status/ike3p58hljpyffrl?svg=true)](https://ci.appveyor.com/project/pekim/tedious)
 
 Tedious is an implementation of the [TDS protocol](http://msdn.microsoft.com/en-us/library/dd304523.aspx),
 which is used to interact with instances of Microsoft's SQL Server. It is intended to be a fairly slim implementation of the protocol, with not too much additional functionality.

package/appveyor.yml

@@ -4,10 +4,14 @@ environment:
   matrix:
     - nodejs_version: "0.10"
     - nodejs_version: "0.12"
-    - nodejs_version: "1.0"
-    - nodejs_version: "1.8"
-    - nodejs_version: "2.0"
-    - nodejs_version: "2.3"
+    - nodejs_version: "4"
+    - nodejs_version: "5"
+
+branches:
+  only:
+    - master
+    - /^maint\/.+/
+    - /v\d+\.\d+\.\d+/
 
 install:
   - ps: Install-Product node $env:nodejs_version
@@ -36,7 +40,7 @@ test_script:
       powershell %cd%\scripts\appveyor\config.ps1 SQL2008R2SP2
       npm run-script test-integration || SET EXITVAL=1
       net stop MSSQL$SQL2008R2SP2
-      
+
       powershell %cd%\scripts\appveyor\config.ps1 SQL2012SP1
       npm run-script test-integration || SET EXITVAL=1
       net stop MSSQL$SQL2012SP1

package/benchmarks/README.md

@@ -0,0 +1,33 @@
+# Tedious Benchmarks
+
+This folder contains a collection of benchmarks for `tedious`.
+
+Running all existing benchmarks is easy, just execute the following from
+inside the `tedious` root folder:
+
+```sh
+node benchmarks
+```
+
+**NOTE:** The benchmarks try to load `tedious` code from `lib`, so make sure
+you run `npm run prepublish` first.
+
+This will serially execute every available benchmark test in a
+seperate Node.js process. Running each benchmark in a separate process
+ensures that each benchmark is run with a clean slate.
+
+You can also execute a specific benchmarks:
+
+```sh
+node benchmarks/<type>/<benchmark-name>
+```
+
+The benchmarks are executed by using the `benchmark` module. Unfortunately,
+this module can add a bit of useless noise when trying to collect profiling
+information. To reduce this noise, benchmarks can be run in a special "profile"
+mode. This will execute the benchmark's code without making use of `benchmark`
+library and with a fixed number of iterations.
+
+```sh
+node benchmarks/<type>/<benchmark-name> --profile
+```

package/benchmarks/common.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var fs = require("fs");
+var async = require("async");
+var Benchmark = require("benchmark");
+var Connection = require("../lib/tedious").Connection;
+
+function createConnection(cb) {
+  var config = JSON.parse(fs.readFileSync(process.env.HOME + '/.tedious/test-connection.json', 'utf8')).config;
+
+  var connection = new Connection(config);
+  connection.on("connect", function() {
+    cb(connection);
+  });
+}
+
+function createBenchmark(test) {
+  if (process.argv.indexOf("--profile") != -1) {
+    process.nextTick(function() {
+      runProfile(test);
+    });
+  } else {
+    process.nextTick(function() {
+      runBenchmark(test);
+    });
+  }
+}
+
+function runBenchmark(test) {
+  var memStart, memMax = memStart = process.memoryUsage().rss;
+
+  test.setup(function(err) {
+    if (err) throw err;
+
+    var bm = new Benchmark(test.name, {
+      defer: true,
+      fn: function(deferred) {
+        test.exec(function(err) {
+          if (err) throw err;
+
+          memMax = Math.max(memMax, process.memoryUsage().rss);
+
+          deferred.resolve();
+        });
+      }
+    });
+
+    bm.on("complete", function(event) {
+      console.log(String(event.target))
+      console.log("Memory:", (memMax - memStart)/1024/1024, "MiB")
+
+      test.teardown(function(err) {
+        if (err) throw err;
+      });
+    });
+
+    bm.run({ "async": true });
+  });
+}
+
+function runProfile(test) {
+  test.setup(function(err) {
+    if (err) throw err;
+
+    async.timesSeries(test.profileIterations, function(n, done) {
+      async.setImmediate(function() {
+        console.log("[Iteration " +  n + "]");
+        test.exec(done);
+      });
+    }, function(err) {
+      if (err) throw err;
+
+      test.teardown(function(err) {
+        if (err) throw err;
+      });
+    });
+  });
+}
+
+module.exports.createBenchmark = createBenchmark;
+module.exports.createConnection = createConnection;
+

package/benchmarks/index.js

@@ -0,0 +1,34 @@
+var fs = require("fs");
+var path = require("path");
+var childProcess = require("child_process")
+var Benchmark = require("benchmark");
+
+var Connection = require("../lib/tedious").Connection;
+var Request = require("../lib/tedious").Request;
+
+var types = ["query", "token-parser"];
+var tests = [];
+
+types.forEach(function(type) {
+  var dir = path.join(__dirname, type);
+  tests.push.apply(tests, fs.readdirSync(dir).map(function(file) {
+    return path.join(dir, file);
+  }));
+});
+
+runBenchmarks();
+
+function runBenchmarks() {
+  var test = tests.shift();
+  if (!test)
+    return;
+
+  var child = childProcess.spawn(process.execPath, [ test ], { stdio: 'inherit' });
+  child.on('close', function(code) {
+    if (code) {
+      process.exit(code);
+    } else {
+      runBenchmarks();
+    }
+  });
+}

package/benchmarks/query/many-result-rows.js

@@ -0,0 +1,49 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+var async = require("async");
+
+var common = require("../common");
+
+var connection;
+common.createBenchmark({
+  name: "Many result rows",
+  profileIterations: 10,
+
+  setup: function(cb) {
+    common.createConnection(function(_connection) {
+      connection = _connection;
+
+      var request = new Request("CREATE TABLE #benchmark ([id] int IDENTITY(1,1), [name] nvarchar(100), [description] nvarchar(max))", function(err) {
+        if (err) return cb(err);
+
+        async.timesSeries(10000, function(n, next) {
+          var request = new Request("INSERT INTO #benchmark ([name], [description]) VALUES (@name, @description)", next);
+
+          request.addParameter("name", TYPES.NVarChar, "Row " + n);
+          request.addParameter("description", TYPES.NVarChar, "Example Test Description for Row " + n);
+
+          connection.execSql(request);
+        }, cb);
+      });
+
+      connection.execSqlBatch(request);
+    });
+  },
+
+  exec: function(cb) {
+    var request = new Request("SELECT * FROM #benchmark", cb);
+    connection.execSql(request);
+  },
+
+  teardown: function(cb) {
+    var request = new Request("DROP TABLE #benchmark", function(err) {
+      if (err) {
+        return cb(err);
+      }
+
+      connection.close();
+    });
+    connection.execSqlBatch(request);
+  }
+});

package/benchmarks/query/nvarchar-large.js

@@ -0,0 +1,44 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+
+var common = require("../common");
+
+var connection;
+common.createBenchmark({
+  name: "inserting nvarchar(max) with 5242880 chars",
+
+  profileIterations: 100,
+
+  setup: function(cb) {
+    common.createConnection(function(_connection) {
+      connection = _connection;
+
+      var request = new Request("CREATE TABLE #benchmark ([value] nvarchar(max))", function(err) {
+        if (err) return cb(err);
+
+        var request = new Request("INSERT INTO #benchmark ([value]) VALUES (@value)", cb);
+        request.addParameter("value", TYPES.NVarChar, new Array(5 * 1024 * 1024).join("x"));
+        connection.execSql(request);
+      });
+
+      connection.execSqlBatch(request);
+    });
+  },
+
+  exec: function(cb) {
+    var request = new Request("SELECT * FROM #benchmark", cb);
+    connection.execSql(request);
+  },
+
+  teardown: function(cb) {
+    var request = new Request("DROP TABLE #benchmark", function(err) {
+      if (err) {
+        return cb(err);
+      }
+
+      connection.close();
+    });
+    connection.execSqlBatch(request);
+  }
+});

package/benchmarks/query/nvarchar-small.js

@@ -0,0 +1,44 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+
+var common = require("../common");
+
+var connection;
+common.createBenchmark({
+  name: "inserting nvarchar(max) with 4 chars",
+
+  profileIterations: 10000,
+
+  setup: function(cb) {
+    common.createConnection(function(_connection) {
+      connection = _connection;
+
+      var request = new Request("CREATE TABLE #benchmark ([value] nvarchar(max))", function(err) {
+        if (err) return cb(err);
+
+        var request = new Request("INSERT INTO #benchmark ([value]) VALUES (@value)", cb);
+        request.addParameter("value", TYPES.NVarChar, "asdf");
+        connection.execSql(request);
+      });
+
+      connection.execSqlBatch(request);
+    });
+  },
+
+  exec: function(cb) {
+    var request = new Request("SELECT * FROM #benchmark", cb);
+    connection.execSql(request);
+  },
+
+  teardown: function(cb) {
+    var request = new Request("DROP TABLE #benchmark", function(err) {
+      if (err) {
+        return cb(err);
+      }
+
+      connection.close();
+    });
+    connection.execSqlBatch(request);
+  }
+});

package/benchmarks/query/varbinary-4.js

@@ -0,0 +1,42 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+
+var common = require("../common");
+
+var connection;
+common.createBenchmark({
+  name: "inserting varbinary(4) with 4 bytes",
+
+  setup: function(cb) {
+    common.createConnection(function(_connection) {
+      connection = _connection;
+
+      var request = new Request("CREATE TABLE #benchmark ([value] varbinary(4))", function(err) {
+        if (err) return cb(err);
+
+        var request = new Request("INSERT INTO #benchmark ([value]) VALUES (@value)", cb);
+        request.addParameter("value", TYPES.VarBinary, new Buffer("asdf"));
+        connection.execSql(request);
+      });
+
+      connection.execSqlBatch(request);
+    });
+  },
+
+  exec: function(cb) {
+    var request = new Request("SELECT * FROM #benchmark", cb);
+    connection.execSql(request);
+  },
+
+  teardown: function(cb) {
+    var request = new Request("DROP TABLE #benchmark", function(err) {
+      if (err) {
+        return cb(err);
+      }
+
+      connection.close();
+    });
+    connection.execSqlBatch(request);
+  }
+});

package/benchmarks/query/varbinary-huge.js

@@ -0,0 +1,46 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+
+var common = require("../common");
+
+var connection;
+common.createBenchmark({
+  name: "inserting varbinary(max) with 50 MiB",
+
+  profileIterations: 20,
+
+  setup: function(cb) {
+    common.createConnection(function(_connection) {
+      connection = _connection;
+
+      var request = new Request("CREATE TABLE #benchmark ([value] varbinary(max))", function(err) {
+        if (err) return cb(err);
+
+        var request = new Request("INSERT INTO #benchmark ([value]) VALUES (@value)", cb);
+        var buf = new Buffer(50 * 1024 * 1024);
+        buf.fill("x");
+        request.addParameter("value", TYPES.VarBinary, buf);
+        connection.execSql(request);
+      });
+
+      connection.execSqlBatch(request);
+    });
+  },
+
+  exec: function(cb) {
+    var request = new Request("SELECT * FROM #benchmark", cb);
+    connection.execSql(request);
+  },
+
+  teardown: function(cb) {
+    var request = new Request("DROP TABLE #benchmark", function(err) {
+      if (err) {
+        return cb(err);
+      }
+
+      connection.close();
+    });
+    connection.execSqlBatch(request);
+  }
+});

package/benchmarks/query/varbinary-large.js

@@ -0,0 +1,46 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+
+var common = require("../common");
+
+var connection;
+common.createBenchmark({
+  name: "inserting varbinary(max) with 5 MiB",
+
+  profileIterations: 100,
+
+  setup: function(cb) {
+    common.createConnection(function(_connection) {
+      connection = _connection;
+
+      var request = new Request("CREATE TABLE #benchmark ([value] varbinary(max))", function(err) {
+        if (err) return cb(err);
+
+        var request = new Request("INSERT INTO #benchmark ([value]) VALUES (@value)", cb);
+        var buf = new Buffer(5 * 1024 * 1024);
+        buf.fill("x");
+        request.addParameter("value", TYPES.VarBinary, buf);
+        connection.execSql(request);
+      });
+
+      connection.execSqlBatch(request);
+    });
+  },
+
+  exec: function(cb) {
+    var request = new Request("SELECT * FROM #benchmark", cb);
+    connection.execSql(request);
+  },
+
+  teardown: function(cb) {
+    var request = new Request("DROP TABLE #benchmark", function(err) {
+      if (err) {
+        return cb(err);
+      }
+
+      connection.close();
+    });
+    connection.execSqlBatch(request);
+  }
+});

package/benchmarks/query/varbinary-small.js

@@ -0,0 +1,42 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+
+var common = require("../common");
+
+var connection;
+common.createBenchmark({
+  name: "inserting varbinary(max) with 4 bytes",
+
+  setup: function(cb) {
+    common.createConnection(function(_connection) {
+      connection = _connection;
+
+      var request = new Request("CREATE TABLE #benchmark ([value] varbinary(max))", function(err) {
+        if (err) return cb(err);
+
+        var request = new Request("INSERT INTO #benchmark ([value]) VALUES (@value)", cb);
+        request.addParameter("value", TYPES.VarBinary, new Buffer("asdf"));
+        connection.execSql(request);
+      });
+
+      connection.execSqlBatch(request);
+    });
+  },
+
+  exec: function(cb) {
+    var request = new Request("SELECT * FROM #benchmark", cb);
+    connection.execSql(request);
+  },
+
+  teardown: function(cb) {
+    var request = new Request("DROP TABLE #benchmark", function(err) {
+      if (err) {
+        return cb(err);
+      }
+
+      connection.close();
+    });
+    connection.execSqlBatch(request);
+  }
+});

package/benchmarks/token-parser/colmetadata-token.js

@@ -0,0 +1,42 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+
+var Parser = require("../../lib/token/token-stream-parser").Parser;
+
+var common = require("../common");
+
+var parser = new Parser({ token: function() { } }, {}, {});
+
+var tokenCount = 50;
+var data = new Buffer(new Array(tokenCount).join("810300000000001000380269006400000000000900e7c8000904d00034046e0061006d006500000000000900e7ffff0904d000340b6400650073006300720069007000740069006f006e00"), "hex");
+
+common.createBenchmark({
+  name: "parsing `COLMETADATA` tokens",
+
+  profileIterations: 3000,
+
+  setup: function(cb) {
+    cb();
+  },
+
+  exec: function(cb) {
+    var count = 0;
+
+    parser.on("columnMetadata", function() {
+      count += 1;
+
+      if (count === tokenCount - 1) {
+        parser.removeAllListeners("columnMetadata");
+
+        cb();
+      }
+    });
+
+    parser.addBuffer(data);
+  },
+
+  teardown: function(cb) {
+    cb();
+  }
+});

package/benchmarks/token-parser/done-token.js

@@ -0,0 +1,42 @@
+var tedious = require("../../lib/tedious");
+var Request = tedious.Request;
+var TYPES = tedious.TYPES;
+
+var Parser = require("../../lib/token/token-stream-parser").Parser;
+
+var common = require("../common");
+
+var parser = new Parser({ token: function() { } }, {}, {});
+
+var tokenCount = 500;
+var data = new Buffer(new Array(tokenCount).join("FE0000E0000000000000000000"), "hex");
+
+common.createBenchmark({
+  name: "parsing `DONEPROC` tokens",
+
+  profileIterations: 3000,
+
+  setup: function(cb) {
+    cb();
+  },
+
+  exec: function(cb) {
+    var count = 0;
+
+    parser.on("doneProc", function() {
+      count += 1;
+
+      if (count === tokenCount - 1) {
+        parser.removeAllListeners("doneProc");
+
+        cb();
+      }
+    });
+
+    parser.addBuffer(data);
+  },
+
+  teardown: function(cb) {
+    cb();
+  }
+});