Initial setup for ms sql server support

Makefile

@@ -38,6 +38,8 @@ sqlite:
 	@DIALECT=sqlite make test
 mysql:
 	@DIALECT=mysql make test
+mssql:
+	@DIALECT=mssql make test
 postgres:
 	@DIALECT=postgres make test
 postgres-native:

lib/dialects/mssql/connection-manager.js

+"use strict";
+var AbstractConnectionManager = require('../abstract/connection-manager')
+  , ConnectionManager
+  , Utils = require('../../utils')
+  , Promise = require('../../promise');
+
+ConnectionManager = function(dialect, sequelize) {
+  AbstractConnectionManager.call(this, dialect, sequelize);
+
+  this.sequelize = sequelize;
+  this.sequelize.config.port = this.sequelize.config.port || 1433;
+
+  try {
+    this.lib = require(sequelize.config.dialectModulePath || 'seriate');
+  } catch (err) {
+    throw new Error('Please install seriate package manually');
+  }
+};
+
+Utils._.extend(ConnectionManager.prototype, AbstractConnectionManager.prototype);
+
+ConnectionManager.prototype.connect = function(config) {
+  var self = this;
+
+  return new Promise(function (resolve, reject) {
+    var connectionConfig = {
+      host: config.host,
+      port: config.port,
+      user: config.username,
+      password: config.password,
+      database: config.database,
+      timezone: self.sequelize.options.timezone
+    };
+
+    if (config.dialectOptions) {
+      Object.keys(config.dialectOptions).forEach(function(key) {
+        connectionConfig[key] = config.dialectOptions[key];
+      });
+    }
+
+    var connection = {
+      config: {
+        user: connectionConfig.user,
+        password: connectionConfig.password,
+        server: connectionConfig.host,
+        database: connectionConfig.database
+      },
+
+      lib: self.lib
+    };
+
+    resolve(connection);
+  });
+};
+ConnectionManager.prototype.disconnect = function(connection) {
+  return new Promise(function (resolve, reject) {
+    resolve();
+  });
+};
+ConnectionManager.prototype.validate = function(connection) {
+  // console.log('add code for validations here', connection);
+  return true;
+};
+
+module.exports = ConnectionManager;

lib/dialects/mssql/index.js

+'use strict';
+
+var _ = require('lodash')
+  , Abstract = require('../abstract')
+  , ConnectionManager = require('./connection-manager')
+  , Query = require('./query');
+
+var MssqlDialect = function(sequelize) {
+  this.sequelize = sequelize;
+  this.connectionManager = new ConnectionManager(this, sequelize);
+  this.connectionManager.initPools();
+};
+
+MssqlDialect.prototype.supports = _.merge(_.cloneDeep(Abstract.prototype.supports), {
+});
+
+MssqlDialect.prototype.Query = Query;
+
+module.exports = MssqlDialect;

lib/dialects/mssql/query-generator.js

+'use strict';
+
+var Utils = require('../../utils');
+
+module.exports = (function() {
+  var QueryGenerator = { dialect: 'mssql' };
+
+  return Utils._.extend(Utils._.clone(require('../mysql/query-generator')), QueryGenerator);
+})();

lib/dialects/mssql/query.js

+'use strict';
+
+var Utils = require('../../utils')
+  , AbstractQuery = require('../abstract/query')
+  , uuid = require('node-uuid');
+
+module.exports = (function() {
+  var Query = function(connection, sequelize, callee, options) {
+    this.connection = connection;
+    this.callee = callee;
+    this.sequelize = sequelize;
+    this.uuid = uuid.v4();
+    this.options = Utils._.extend({
+      logging: console.log,
+      plain: false,
+      raw: false
+    }, options || {});
+
+    var self = this;
+    this.checkLoggingOption();
+  };
+
+  Utils.inherit(Query, AbstractQuery);
+
+  Query.prototype.run = function(sql) {
+    var self = this;
+    this.sql = sql;
+
+    if (this.options.logging !== false) {
+      this.sequelize.log('Executing (' + this.connection.uuid + '): ' + this.sql);
+    }
+
+    var promise = new Utils.Promise(function(resolve, reject) {
+      console.log(self.sql);
+
+      self
+        .connection
+        .lib
+        .execute(self.connection.config, { query: self.sql })
+        .then(
+          function (data) { resolve(data.result); },
+          function (err) { reject(err); }
+        );
+    });
+
+    return promise;
+  };
+
+  return Query;
+})();

test/config/config.js

@@ -12,6 +12,18 @@ module.exports = {
     return parseInt(Math.random() * 999, 10)
   },
 
+  mssql: {
+    database: process.env.SEQ_MSSQL_DB   || process.env.SEQ_DB   || ('sequelize_test_' + ~~(Math.random() * 100)),
+    username: process.env.SEQ_MSSQL_USER || process.env.SEQ_USER || "sequelize",
+    password: process.env.SEQ_MSSQL_PW   || process.env.SEQ_PW   || "53qu3l1z3",
+    host:     process.env.SEQ_MSSQL_HOST || process.env.SEQ_HOST || "server2.barfooz.net",
+    port:     process.env.SEQ_MSSQL_PORT || process.env.SEQ_PORT || 1433,
+    pool:     {
+      maxConnections: process.env.SEQ_MSSQL_POOL_MAX  || process.env.SEQ_POOL_MAX  || 5,
+      maxIdleTime:    process.env.SEQ_MSSQL_POOL_IDLE || process.env.SEQ_POOL_IDLE || 3000
+    }
+  },
+
   //make maxIdleTime small so that tests exit promptly
   mysql: {
     database: process.env.SEQ_MYSQL_DB   || process.env.SEQ_DB   || 'sequelize_test',