move more logic to data types

Makefile

@@ -27,7 +27,7 @@ endif
 test-unit:
 	./node_modules/mocha/bin/mocha --globals setImmediate,clearImmediate --ui tdd --check-leaks --colors -t 10000 --reporter $(REPORTER) ./test/unit/**/*.js
 
-test-unit-all: test-unit-sqlite test-unit-mysql test-unit-postgres test-unit-postgres-native test-unit-mariadb
+test-unit-all: test-unit-sqlite test-unit-mysql test-unit-postgres test-unit-postgres-native test-unit-mariadb test-unit-mssql
 
 test-unit-mariadb:
 	@DIALECT=mariadb make test-unit
@@ -50,7 +50,7 @@ test-integration:
 		./node_modules/mocha/bin/mocha --globals setImmediate,clearImmediate --ui tdd --check-leaks --colors -t 10000 --reporter $(REPORTER) $(TESTS); \
 	fi
 
-test-integration-all: test-integration-sqlite test-integration-mysql test-integration-postgres test-integration-postgres-native test-integration-mariadb
+test-integration-all: test-integration-sqlite test-integration-mysql test-integration-postgres test-integration-postgres-native test-integration-mariadb test-integration-mssql
 
 test-integration-mariadb:
 	@DIALECT=mariadb make test-integration

lib/data-types.js

@@ -41,6 +41,7 @@ STRING.prototype.toSql = function() {
 Object.defineProperty(STRING.prototype, 'BINARY', {
   get: function() {
     this._binary = true;
+    this.options.binary = true;
     return this;
   }
 });
@@ -82,9 +83,9 @@ TEXT.prototype.key = TEXT.key = 'TEXT';
 
 
 var NUMBER = function(options) {
-  if (!(this instanceof NUMBER)) return new NUMBER(options);
   this.options = options;
   this._length = options.length;
+  this._zerofill = options.zerofill;
   this._decimals = options.decimals;
   this._precision = options.precision;
   this._scale = options.scale;
@@ -114,12 +115,14 @@ NUMBER.prototype.toSql = function() {
 Object.defineProperty(NUMBER.prototype, 'UNSIGNED', {
   get: function() {
     this._unsigned = true;
+    this.options.unsigned = true;
     return this;
   }
 });
 Object.defineProperty(NUMBER.prototype, 'ZEROFILL', {
   get: function() {
     this._zerofill = true;
+    this.options.zerofill = true;
     return this;
   }
 });
@@ -519,6 +522,7 @@ module.exports = {
   STRING: STRING,
   CHAR: CHAR,
   TEXT: TEXT,
+  NUMBER: NUMBER,
   INTEGER: INTEGER,
   BIGINT: BIGINT,
   FLOAT: FLOAT,

lib/dialects/abstract/query-generator.js

@@ -1697,7 +1697,6 @@ module.exports = (function() {
 
       // Setup keys and comparators
       if (Array.isArray(value) && fieldType instanceof DataTypes.ARRAY) {
-        // Stupid horrible PG ARRAY checking, need a new way
         value = this.escape(value, field);
       } else if (value && (value.$in || Array.isArray(value) || (value.$not && Array.isArray(value.$not)) || value.$notIn)) {
         comparator = 'IN';

lib/dialects/mssql/data-types.js

@@ -58,11 +58,22 @@ NOW.prototype.toSql = function() {
   return 'GETDATE()';
 };
 
+var DATE = function() {
+  if (!(this instanceof DATE)) return new DATE();
+  BaseTypes.DATE.apply(this, arguments);
+};
+util.inherits(DATE, BaseTypes.DATE);
+
+DATE.prototype.toSql = function() {
+  return 'DATETIME2';
+};
+
 module.exports = {
   BOOLEAN: BOOLEAN,
   STRING: STRING,
   BLOB: BLOB,
   UUID: UUID,
+  DATE: DATE,
   NOW: NOW
 };
 

lib/dialects/mssql/query-generator.js

@@ -351,7 +351,7 @@ module.exports = (function() {
         }.bind(this)).join(', ') + '))';
         return template;
       } else {
-        template = mssqlDataTypeMapping(null, null, attribute.type.toString());
+        template = attribute.type.toString();
       }
 
       if (attribute.allowNull === false) {
@@ -611,26 +611,6 @@ module.exports = (function() {
     return Utils.addTicks(identifier, "'");
   }
 
-  function mssqlDataTypeMapping(tableName, attr, dataType) {
-    if (Utils._.includes(dataType, 'TINYINT(1)')) {
-      dataType = dataType.replace(/TINYINT\(1\)/, 'BIT');
-    }
-
-    if (Utils._.includes(dataType, 'DATETIME')) {
-      dataType = dataType.replace(/DATETIME/, 'DATETIME2');
-    }
-
-    if (Utils._.includes(dataType, 'BLOB')) {
-      dataType = dataType.replace(/BLOB/, 'VARBINARY(MAX)');
-    }
-
-    if (Utils._.includes(dataType, 'UUID')) {
-      dataType = dataType.replace(/UUID/, DataTypes.UUID);
-    }
-
-    return dataType;
-  }
-
   /* istanbul ignore next */
   var throwMethodUndefined = function(methodName) {
     throw new Error('The method "' + methodName + '" is not defined! Please add it to your sql dialect.');

lib/dialects/postgres/data-types.js

@@ -4,6 +4,32 @@ var BaseTypes = require('../../data-types')
   , util = require('util')
   , _ = require('lodash');
 
+var STRING = function() {
+  if (!(this instanceof STRING)) return new STRING();
+  BaseTypes.STRING.apply(this, arguments);
+};
+util.inherits(STRING, BaseTypes.STRING);
+
+STRING.prototype.toSql = function() {
+  if (this._binary) {
+    return 'BYTEA';
+  }
+  return BaseTypes.STRING.prototype.toSql.call(this);
+};
+
+var CHAR = function() {
+  if (!(this instanceof CHAR)) return new CHAR();
+  BaseTypes.CHAR.apply(this, arguments);
+};
+util.inherits(CHAR, BaseTypes.CHAR);
+
+CHAR.prototype.toSql = function() {
+  if (this._binary) {
+    return 'BYTEA';
+  }
+  return BaseTypes.CHAR.prototype.toSql.call(this);
+};
+
 var BOOLEAN = function() {
   if (!(this instanceof BOOLEAN)) return new BOOLEAN();
   BaseTypes.BOOLEAN.apply(this, arguments);
@@ -44,11 +70,24 @@ var BIGINT = function() {
 };
 util.inherits(BIGINT, BaseTypes.BIGINT);
 
+var BLOB = function() {
+  if (!(this instanceof BLOB)) return new BLOB();
+  BaseTypes.BLOB.apply(this, arguments);
+};
+util.inherits(BLOB, BaseTypes.BLOB);
+
+BLOB.prototype.toSql = function() {
+  return 'BYTEA';
+};
+
 module.exports = {
+  STRING: STRING,
+  CHAR: CHAR,
   BOOLEAN: BOOLEAN,
   DATE: DATE,
   INTEGER: INTEGER,
-  BIGINT: BIGINT
+  BIGINT: BIGINT,
+  BLOB: BLOB
 };
 
 _.forIn(module.exports, function (DataType, key) {

lib/dialects/postgres/query-generator.js

@@ -834,10 +834,6 @@ module.exports = (function() {
         }
         dataType = dataType.replace(/NOT NULL/, '');
       }
-      
-      if (dataType.lastIndexOf('BLOB') !== -1 || dataType.lastIndexOf('BINARY') !== -1) {
-        dataType = 'bytea';
-      }
 
       if (dataType.match(/^ENUM\(/)) {
         dataType = dataType.replace(/^ENUM\(.+\)/, this.pgEscapeAndQuote('enum_' + tableName + '_' + attr));

lib/dialects/sqlite/data-types.js

+'use strict';
+
+var BaseTypes = require('../../data-types')
+  , util = require('util')
+  , _ = require('lodash');
+
+var STRING = function() {
+  if (!(this instanceof STRING)) return new STRING();
+  BaseTypes.STRING.apply(this, arguments);
+};
+util.inherits(STRING, BaseTypes.STRING);
+
+STRING.prototype.toSql = function() {
+  if (this._binary) {
+    return 'VARCHAR BINARY(' + this._length + ')';
+  } else {
+    return BaseTypes.STRING.prototype.toSql.call(this);
+  }
+};
+
+var CHAR = function() {
+  if (!(this instanceof CHAR)) return new CHAR();
+  BaseTypes.CHAR.apply(this, arguments);
+};
+util.inherits(CHAR, BaseTypes.CHAR);
+
+CHAR.prototype.toSql = function() {
+  if (this._binary) {
+    return 'CHAR BINARY(' + this._length + ')';
+  } else {
+    return BaseTypes.CHAR.prototype.toSql.call(this);
+  }
+};
+
+var NUMBER = function() {
+  BaseTypes.NUMBER.apply(this, arguments);
+};
+util.inherits(NUMBER, BaseTypes.NUMBER);
+
+NUMBER.prototype.toSql = function() {
+  var result = this.key;
+
+  if (this._unsigned) {
+    result += ' UNSIGNED';
+  }
+  if (this._zerofill) {
+    result += ' ZEROFILL';
+  }
+
+  if (this._length) {
+    result += '(' + this._length;
+    if (typeof this._decimals === 'number') {
+      result += ',' + this._decimals;
+    }
+    result += ')';
+  }
+  return result;
+};
+
+var INTEGER = function(length) {
+  var options = typeof length === "object" && length || {
+    length: length
+  };
+  if (!(this instanceof INTEGER)) return new INTEGER(options);
+  NUMBER.call(this, options);
+};
+util.inherits(INTEGER, BaseTypes.INTEGER);
+INTEGER.prototype.key = INTEGER.key = 'INTEGER';
+INTEGER.prototype.toSql = function() {
+  return NUMBER.prototype.toSql.call(this);
+};
+
+var BIGINT = function(length) {
+  var options = typeof length === "object" && length || {
+    length: length
+  };
+  if (!(this instanceof BIGINT)) return new BIGINT(options);
+  NUMBER.call(this, options);
+};
+util.inherits(BIGINT, BaseTypes.BIGINT);
+BIGINT.prototype.key = BIGINT.key = 'BIGINT';
+BIGINT.prototype.toSql = function() {
+  return NUMBER.prototype.toSql.call(this);
+};
+
+var FLOAT = function(length, decimals) {
+  var options = typeof length === "object" && length || {
+    length: length,
+    decimals: decimals
+  };
+  if (!(this instanceof FLOAT)) return new FLOAT(options);
+  NUMBER.call(this, options); 
+};
+util.inherits(FLOAT, BaseTypes.FLOAT);
+FLOAT.prototype.key = FLOAT.key = 'FLOAT';
+FLOAT.prototype.toSql = function() {
+  return NUMBER.prototype.toSql.call(this);
+};
+
+module.exports = {
+  STRING: STRING,
+  CHAR: CHAR,
+  NUMBER: NUMBER,
+  FLOAT: FLOAT,
+  INTEGER: INTEGER,
+  BIGINT: BIGINT
+};
+
+_.forIn(module.exports, function (DataType, key) {
+  if (!DataType.key) DataType.key = key;
+  if (!DataType.extend) {
+    DataType.extend = function(oldType) {
+      return new DataType(oldType.options);
+    };
+  }
+});
\ No newline at end of file

lib/dialects/sqlite/index.js

@@ -4,7 +4,8 @@ var _ = require('lodash')
   , Abstract = require('../abstract')
   , ConnectionManager = require('./connection-manager')
   , Query = require('./query')
-  , QueryGenerator = require('./query-generator');
+  , QueryGenerator = require('./query-generator')
+  , DataTypes = require('./data-types');
 
 var SqliteDialect = function(sequelize) {
   this.sequelize = sequelize;
@@ -27,6 +28,7 @@ SqliteDialect.prototype.supports = _.merge(_.cloneDeep(Abstract.prototype.suppor
 });
 
 SqliteDialect.prototype.Query = Query;
+SqliteDialect.prototype.DataTypes = DataTypes;
 SqliteDialect.prototype.name = 'sqlite';
 SqliteDialect.prototype.TICK_CHAR = '`';
 SqliteDialect.prototype.TICK_CHAR_LEFT = SqliteDialect.prototype.TICK_CHAR;

lib/dialects/sqlite/query-generator.js

@@ -51,34 +51,6 @@ module.exports = (function() {
             dataType = dataType.replace(/BIGINT/, 'INTEGER');
           }
 
-          // SQLite thinks that certain modifiers should come before the length declaration,
-          // whereas other dialects want them after, see http://www.sqlite.org/lang_createtable.html.
-
-          // Start by finding the index of the last of the modifiers
-          ['UNSIGNED', 'BINARY', 'ZEROFILL'].forEach(function (modifier) {
-            var tmpIndex = dataType.indexOf(modifier);
-
-            if (tmpIndex > modifierLastIndex) {
-              modifierLastIndex = tmpIndex + modifier.length;
-            }
-          });
-
-          if (modifierLastIndex) {
-            // If a modifier was found, and a lenght declaration is given before the modifier, move the length
-            var length = dataType.match(/\(\s*\d+(\s*,\s*\d)?\s*\)/);
-            if (length && length.index < modifierLastIndex) {
-              dataType = dataType.replace(length[0], '');
-
-              // Since the legnth was placed before the modifier, removing the length has changed the index
-              if (length.index < modifierLastIndex) {
-                modifierLastIndex -= length[0].length;
-              }
-              dataType = Utils.spliceStr(dataType, modifierLastIndex, 0, length[0]).trim();
-            }
-
-            modifierLastIndex = -1;
-          }
-
           var dataTypeString = dataType;
           if (Utils._.includes(dataType, 'PRIMARY KEY')) {
             if (Utils._.includes(dataType, 'INTEGER')) {

lib/sequelize.js

@@ -188,6 +188,7 @@ module.exports = (function() {
       var Dialect = require('./dialects/' + this.getDialect());
       this.dialect = new Dialect(this);
     } catch (err) {
+      console.log(err.stack);
       throw new Error('The dialect ' + this.getDialect() + ' is not supported. ('+err+')');
     }
 

test/integration/data-types.test.js

-'use strict';
-
-var chai = require('chai')
-  , expect = chai.expect
-  , Sequelize = require(__dirname + '/../../index')
-  , Support = require(__dirname + '/support')
-  , current = Support.sequelize;
-
-chai.config.includeStack = true;
-
-describe.skip(Support.getTestDialectTeaser('DataTypes'), function() {
-  it('should return false when comparing DECIMAL and DECIMAL(10,2)', function(done) {
-    expect(Sequelize.DECIMAL).to.not.equal(Sequelize.DECIMAL(10, 2));
-    done();
-  });
-
-  it('DECIMAL(10,2) should be an instance of DECIMAL', function(done) {
-    expect(Sequelize.DECIMAL(10, 2)).to.be.an.instanceof(Sequelize.DECIMAL);
-    done();
-  });
-
-  it('should return false when comparing FLOAT and FLOAT(11)', function(done) {
-    expect(Sequelize.FLOAT).to.not.equal(Sequelize.FLOAT(11));
-    done();
-  });
-
-  it('FLOAT(11) should be an instance of FLOAT', function(done) {
-    expect(Sequelize.FLOAT(11)).to.be.an.instanceof(Sequelize.FLOAT);
-    done();
-  });
-
-  it('should return false when comparing STRING and STRING(4096)', function(done) {
-    expect(Sequelize.STRING).to.not.equal(Sequelize.STRING(4096));
-    done();
-  });
-
-  it('STRING(4096) should be an instance of STRING', function(done) {
-    expect(Sequelize.STRING(4096)).to.be.an.instanceof(Sequelize.STRING);
-    done();
-  });
-
-  it('should return false when comparing BIGINT and BIGINT(11)', function(done) {
-    expect(Sequelize.BIGINT).to.not.equal(Sequelize.BIGINT(11));
-    done();
-  });
-
-  it('BIGINT(11) should be an instance of BIGINT', function(done) {
-    expect(Sequelize.BIGINT(11)).to.be.an.instanceof(Sequelize.BIGINT);
-    done();
-  });
-
-  var tests = [
-    [Sequelize.STRING, 'STRING', 'VARCHAR(255)'],
-    [Sequelize.STRING(1234), 'STRING(1234)', 'VARCHAR(1234)'],
-    [Sequelize.STRING(1234).BINARY, 'STRING(1234).BINARY', 'VARCHAR(1234) BINARY'],
-    [Sequelize.STRING.BINARY, 'STRING.BINARY', 'VARCHAR(255) BINARY'],
-
-    [Sequelize.CHAR, 'CHAR(255)', 'CHAR(255)'],
-    [Sequelize.CHAR(12), 'CHAR(12)', 'CHAR(12)'],
-    [Sequelize.CHAR(12).BINARY, 'CHAR(12).BINARY', 'CHAR(12) BINARY'],
-    [Sequelize.CHAR.BINARY, 'CHAR(255).BINARY', 'CHAR(255) BINARY'],
-
-    [Sequelize.TEXT, 'TEXT', 'TEXT'],
-    [Sequelize.DATE, 'DATE', 'DATETIME'],
-    [Sequelize.TIME, 'TIME', 'TIME'],
-    [Sequelize.NOW, 'NOW', 'NOW'],
-    [Sequelize.UUID, 'UUID', 'UUID'],
-    [Sequelize.BOOLEAN, 'BOOLEAN', 'TINYINT(1)'],
-
-    [Sequelize.BLOB, 'BLOB', 'BLOB'],
-    [Sequelize.BLOB('tiny'), 'BLOB(\'tiny\')', 'TINYBLOB'],
-    [Sequelize.BLOB('medium'), 'BLOB(\'medium\')', 'MEDIUMBLOB'],
-    [Sequelize.BLOB('long'), 'BLOB(\'long\')', 'LONGBLOB'],
-   
-    [Sequelize.INTEGER, 'INTEGER', 'INTEGER'],
-    [Sequelize.INTEGER.UNSIGNED, 'INTEGER.UNSIGNED', 'INTEGER UNSIGNED'],
-    [Sequelize.INTEGER.UNSIGNED.ZEROFILL, 'INTEGER.UNSIGNED', 'INTEGER UNSIGNED ZEROFILL'],
-    [Sequelize.INTEGER(11), 'INTEGER(11)', 'INTEGER(11)'],
-    [Sequelize.INTEGER(11).UNSIGNED, 'INTEGER(11).UNSIGNED', 'INTEGER(11) UNSIGNED'],
-    [Sequelize.INTEGER(11).UNSIGNED.ZEROFILL, 'INTEGER(11).UNSIGNED.ZEROFILL', 'INTEGER(11) UNSIGNED ZEROFILL'],
-    [Sequelize.INTEGER(11).ZEROFILL, 'INTEGER(11).ZEROFILL', 'INTEGER(11) ZEROFILL'],
-    [Sequelize.INTEGER(11).ZEROFILL.UNSIGNED, 'INTEGER(11).ZEROFILL.UNSIGNED', 'INTEGER(11) UNSIGNED ZEROFILL'],
-    
-    [Sequelize.BIGINT, 'BIGINT', 'BIGINT'],
-    [Sequelize.BIGINT.UNSIGNED, 'BIGINT.UNSIGNED', 'BIGINT UNSIGNED'],
-    [Sequelize.BIGINT(11), 'BIGINT(11)', 'BIGINT(11)'],
-    [Sequelize.BIGINT(11).UNSIGNED, 'BIGINT(11).UNSIGNED', 'BIGINT(11) UNSIGNED'],
-    [Sequelize.BIGINT(11).UNSIGNED.ZEROFILL, 'BIGINT(11).UNSIGNED.ZEROFILL', 'BIGINT(11) UNSIGNED ZEROFILL'],
-    [Sequelize.BIGINT(11).ZEROFILL, 'BIGINT(11).ZEROFILL', 'BIGINT(11) ZEROFILL'],
-    [Sequelize.BIGINT(11).ZEROFILL.UNSIGNED, 'BIGINT(11).ZEROFILL.UNSIGNED', 'BIGINT(11) UNSIGNED ZEROFILL'],
-
-    [Sequelize.FLOAT, 'FLOAT', 'FLOAT'],
-    [Sequelize.FLOAT.UNSIGNED, 'FLOAT.UNSIGNED', 'FLOAT UNSIGNED'],
-    [Sequelize.FLOAT(11), 'FLOAT(11)', 'FLOAT(11)'],
-    [Sequelize.FLOAT(11).UNSIGNED, 'FLOAT(11).UNSIGNED', 'FLOAT(11) UNSIGNED'],
-    [Sequelize.FLOAT(11).UNSIGNED.ZEROFILL, 'FLOAT(11).UNSIGNED.ZEROFILL', 'FLOAT(11) UNSIGNED ZEROFILL'],
-    [Sequelize.FLOAT(11).ZEROFILL, 'FLOAT(11).ZEROFILL', 'FLOAT(11) ZEROFILL'],
-    [Sequelize.FLOAT(11).ZEROFILL.UNSIGNED, 'FLOAT(11).ZEROFILL.UNSIGNED', 'FLOAT(11) UNSIGNED ZEROFILL'],
-
-    [Sequelize.FLOAT(11, 12), 'FLOAT(11,12)', 'FLOAT(11,12)'],
-    [Sequelize.FLOAT(11, 12).UNSIGNED, 'FLOAT(11,12).UNSIGNED', 'FLOAT(11,12) UNSIGNED'],
-    [Sequelize.FLOAT(11, 12).UNSIGNED.ZEROFILL, 'FLOAT(11,12).UNSIGNED.ZEROFILL', 'FLOAT(11,12) UNSIGNED ZEROFILL'],
-    [Sequelize.FLOAT(11, 12).ZEROFILL, 'FLOAT(11,12).ZEROFILL', 'FLOAT(11,12) ZEROFILL'],
-    [Sequelize.FLOAT(11, 12).ZEROFILL.UNSIGNED, 'FLOAT(11,12).ZEROFILL.UNSIGNED', 'FLOAT(11,12) UNSIGNED ZEROFILL'],
-
-    [Sequelize.DECIMAL, 'DECIMAL', 'DECIMAL'],
-    [Sequelize.DECIMAL(10, 2), 'DECIMAL(10,2)', 'DECIMAL(10,2)']
-  ];
-
-  tests.forEach(function(test) {
-    it('transforms "' + test[1] + '" to "' + test[2] + '"', function(done) {
-      if (Support.getTestDialect() === 'mssql') {
-        switch (test[1]) {
-          case 'STRING':
-            test[2] = 'NVARCHAR(255)';
-            break;
-          case 'STRING(1234)':
-            test[2] = 'NVARCHAR(1234)';
-            break;
-          case 'STRING(1234).BINARY':
-            test[2] = 'BINARY(1234)';
-            break;
-          case 'STRING.BINARY':
-            test[2] = 'BINARY(255)';
-            break;
-        }
-      }
-
-      test[0] = current.normalizeDataType(test[0]);
-      expect(test[0].toSql()).to.equal(test[2]);
-      done();
-    });
-  });
-});

test/integration/dialects/postgres/query-generator.test.js

@@ -8,6 +8,7 @@ var chai = require('chai')
   , DataTypes = require(__dirname + '/../../../../lib/data-types')
   , moment = require('moment')
   , util = require('util')
+  , current = Support.sequelize
   , _ = require('lodash');
 
 chai.config.includeStack = true;
@@ -118,12 +119,12 @@ if (dialect.match(/^postgres/)) {
           expectation: 'CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" VARCHAR(255), \"name\" VARCHAR(255));'
         },
         {
-          arguments: ['myTable', {data: 'BLOB'}],
-          expectation: 'CREATE TABLE IF NOT EXISTS \"myTable\" (\"data\" bytea);'
+          arguments: ['myTable', {data: current.normalizeDataType(DataTypes.BLOB).toSql()}],
+          expectation: 'CREATE TABLE IF NOT EXISTS \"myTable\" (\"data\" BYTEA);'
         },
         {
-          arguments: ['myTable', {data: 'LONGBLOB'}],
-          expectation: 'CREATE TABLE IF NOT EXISTS \"myTable\" (\"data\" bytea);'
+          arguments: ['myTable', {data: current.normalizeDataType(DataTypes.BLOB('long')).toSql()}],
+          expectation: 'CREATE TABLE IF NOT EXISTS \"myTable\" (\"data\" BYTEA);'
         },
         {
           arguments: [{tableName: 'myTable', schema: 'mySchema'}, {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}],

test/integration/dialects/sqlite/query-generator.test.js

@@ -91,7 +91,7 @@ if (dialect === 'sqlite') {
           expectation: 'CREATE TABLE IF NOT EXISTS `myTable` (`title` VARCHAR(255), `name` VARCHAR(255));'
         },
         {
-          arguments: ['myTable', {title: 'VARCHAR(255) BINARY', number: 'INTEGER(5) UNSIGNED PRIMARY KEY '}], // length and unsigned are not allowed on primary key
+          arguments: ['myTable', {title: 'VARCHAR BINARY(255)', number: 'INTEGER(5) UNSIGNED PRIMARY KEY '}], // length and unsigned are not allowed on primary key
           expectation: 'CREATE TABLE IF NOT EXISTS `myTable` (`title` VARCHAR BINARY(255), `number` INTEGER PRIMARY KEY);'
         },
         {

test/unit/sql/data-types.test.js

+'use strict';
+
+var Support   = require(__dirname + '/../support')
+  , DataTypes = require(__dirname + '/../../../lib/data-types')
+  , util      = require('util')
+  , expectsql = Support.expectsql
+  , current   = Support.sequelize
+  , sql       = current.dialect.QueryGenerator;
+
+// Notice: [] will be replaced by dialect specific tick/quote character when there is not dialect specific expectation but only a default expectation
+
+suite(Support.getTestDialectTeaser('SQL'), function() {
+  suite('DataTypes', function () {
+    var testsql = function (description, dataType, expectation) {
+      test(description, function () {
+        return expectsql(current.normalizeDataType(dataType).toSql(), expectation);
+      });
+    };
+
+    suite('STRING', function () {
+      testsql('STRING', DataTypes.STRING, {
+        default: 'VARCHAR(255)',
+        mssql: 'NVARCHAR(255)'
+      });
+
+      testsql('STRING(1234)', DataTypes.STRING(1234), {
+        default: 'VARCHAR(1234)',
+        mssql: 'NVARCHAR(1234)'
+      });
+
+      testsql('STRING(1234).BINARY', DataTypes.STRING(1234).BINARY, {
+        default: 'VARCHAR(1234) BINARY',
+        sqlite: 'VARCHAR BINARY(1234)',
+        mssql: 'BINARY(1234)',
+        postgres: 'BYTEA'
+      });
+
+      testsql('STRING.BINARY', DataTypes.STRING.BINARY, {
+        default: 'VARCHAR(255) BINARY',
+        sqlite: 'VARCHAR BINARY(255)',
+        mssql: 'BINARY(255)',
+        postgres: 'BYTEA'
+      });
+    });
+
+    suite('CHAR', function () {
+      testsql('CHAR', DataTypes.CHAR, {
+        default: 'CHAR(255)'
+      });
+
+      testsql('CHAR(12)', DataTypes.CHAR(12), {
+        default: 'CHAR(12)'
+      });
+
+      testsql('CHAR(12).BINARY', DataTypes.CHAR(12).BINARY, {
+        default: 'CHAR(12) BINARY',
+        sqlite: 'CHAR BINARY(12)',
+        postgres: 'BYTEA'
+      });
+
+      testsql('CHAR.BINARY', DataTypes.CHAR.BINARY, {
+        default: 'CHAR(255) BINARY',
+        sqlite: 'CHAR BINARY(255)',
+        postgres: 'BYTEA'
+      });
+    });
+
+    suite('BOOLEAN', function () {
+      testsql('BOOLEAN', DataTypes.BOOLEAN, {
+        postgres: 'BOOLEAN',
+        mssql: 'BIT',
+        mysql: 'TINYINT(1)',
+        sqlite: 'TINYINT(1)'
+      });
+    });
+
+    suite('DATE', function () {
+      testsql('DATE', DataTypes.DATE, {
+        postgres: 'TIMESTAMP WITH TIME ZONE',
+        mssql: 'DATETIME2',
+        mysql: 'DATETIME',
+        sqlite: 'DATETIME'
+      });
+    });
+
+    suite('UUID', function () {
+      testsql('UUID', DataTypes.UUID, {
+        postgres: 'UUID',
+        mssql: 'CHAR(36)',
+        mysql: 'CHAR(36) BINARY',
+        sqlite: 'UUID'
+      });
+    });
+
+    suite('NOW', function () {
+      testsql('NOW', DataTypes.NOW, {
+        default: 'NOW',
+        mssql: 'GETDATE()'
+      });
+    });
+
+    suite('INTEGER', function () {
+      testsql('INTEGER', DataTypes.INTEGER, {
+        default: 'INTEGER'
+      });
+
+      testsql('INTEGER.UNSIGNED', DataTypes.INTEGER.UNSIGNED, {
+        default: 'INTEGER UNSIGNED'
+      });
+
+      testsql('INTEGER.UNSIGNED.ZEROFILL', DataTypes.INTEGER.UNSIGNED.ZEROFILL, {
+        default: 'INTEGER UNSIGNED ZEROFILL'
+      });
+
+      testsql('INTEGER(11)', DataTypes.INTEGER(11), {
+        default: 'INTEGER(11)',
+        postgres: 'INTEGER'
+      });
+
+      testsql('INTEGER(11).UNSIGNED', DataTypes.INTEGER(11).UNSIGNED, {
+        default: 'INTEGER(11) UNSIGNED',
+        sqlite: 'INTEGER UNSIGNED(11)',
+        postgres: 'INTEGER UNSIGNED'
+      });
+
+      testsql('INTEGER(11).UNSIGNED.ZEROFILL', DataTypes.INTEGER(11).UNSIGNED.ZEROFILL, {
+        default: 'INTEGER(11) UNSIGNED ZEROFILL',
+        sqlite: 'INTEGER UNSIGNED ZEROFILL(11)',
+        postgres: 'INTEGER UNSIGNED ZEROFILL'
+      });
+
+      testsql('INTEGER(11).ZEROFILL', DataTypes.INTEGER(11).ZEROFILL, {
+        default: 'INTEGER(11) ZEROFILL',
+        sqlite: 'INTEGER ZEROFILL(11)',
+        postgres: 'INTEGER ZEROFILL'
+      });
+
+      testsql('INTEGER(11).ZEROFILL.UNSIGNED', DataTypes.INTEGER(11).ZEROFILL.UNSIGNED, {
+        default: 'INTEGER(11) UNSIGNED ZEROFILL',
+        sqlite: 'INTEGER UNSIGNED ZEROFILL(11)',
+        postgres: 'INTEGER UNSIGNED ZEROFILL'
+      });
+    });
+
+    suite('BIGINT', function () {
+      testsql('BIGINT', DataTypes.BIGINT, {
+        default: 'BIGINT'
+      });
+
+      testsql('BIGINT.UNSIGNED', DataTypes.BIGINT.UNSIGNED, {
+        default: 'BIGINT UNSIGNED'
+      });
+
+      testsql('BIGINT.UNSIGNED.ZEROFILL', DataTypes.BIGINT.UNSIGNED.ZEROFILL, {
+        default: 'BIGINT UNSIGNED ZEROFILL'
+      });
+
+      testsql('BIGINT(11)', DataTypes.BIGINT(11), {
+        default: 'BIGINT(11)',
+        postgres: 'BIGINT'
+      });
+
+      testsql('BIGINT(11).UNSIGNED', DataTypes.BIGINT(11).UNSIGNED, {
+        default: 'BIGINT(11) UNSIGNED',
+        sqlite: 'BIGINT UNSIGNED(11)',
+        postgres: 'BIGINT UNSIGNED'
+      });
+
+      testsql('BIGINT(11).UNSIGNED.ZEROFILL', DataTypes.BIGINT(11).UNSIGNED.ZEROFILL, {
+        default: 'BIGINT(11) UNSIGNED ZEROFILL',
+        sqlite: 'BIGINT UNSIGNED ZEROFILL(11)',
+        postgres: 'BIGINT UNSIGNED ZEROFILL'
+      });
+
+      testsql('BIGINT(11).ZEROFILL', DataTypes.BIGINT(11).ZEROFILL, {
+        default: 'BIGINT(11) ZEROFILL',
+        sqlite: 'BIGINT ZEROFILL(11)',
+        postgres: 'BIGINT ZEROFILL'
+      });
+
+      testsql('BIGINT(11).ZEROFILL.UNSIGNED', DataTypes.BIGINT(11).ZEROFILL.UNSIGNED, {
+        default: 'BIGINT(11) UNSIGNED ZEROFILL',
+        sqlite: 'BIGINT UNSIGNED ZEROFILL(11)',
+        postgres: 'BIGINT UNSIGNED ZEROFILL'
+      });
+    });
+
+    suite('FLOAT', function () {
+      testsql('FLOAT', DataTypes.FLOAT, {
+        default: 'FLOAT'
+      });
+
+      testsql('FLOAT.UNSIGNED', DataTypes.FLOAT.UNSIGNED, {
+        default: 'FLOAT UNSIGNED'
+      });
+
+      testsql('FLOAT(11)', DataTypes.FLOAT(11), {
+        default:  'FLOAT(11)'
+      });
+
+      testsql('FLOAT(11).UNSIGNED', DataTypes.FLOAT(11).UNSIGNED, {
+        default: 'FLOAT(11) UNSIGNED',
+        sqlite: 'FLOAT UNSIGNED(11)'
+      });
+
+      testsql('FLOAT(11).UNSIGNED.ZEROFILL', DataTypes.FLOAT(11).UNSIGNED.ZEROFILL, {
+        default: 'FLOAT(11) UNSIGNED ZEROFILL',
+        sqlite: 'FLOAT UNSIGNED ZEROFILL(11)'
+      });
+
+      testsql('FLOAT(11).ZEROFILL', DataTypes.FLOAT(11).ZEROFILL, {
+        default: 'FLOAT(11) ZEROFILL',
+        sqlite: 'FLOAT ZEROFILL(11)'
+      });
+
+      testsql('FLOAT(11).ZEROFILL.UNSIGNED', DataTypes.FLOAT(11).ZEROFILL.UNSIGNED, {
+        default: 'FLOAT(11) UNSIGNED ZEROFILL',
+        sqlite: 'FLOAT UNSIGNED ZEROFILL(11)'
+      });
+
+
+      testsql('FLOAT(11, 12)', DataTypes.FLOAT(11, 12), {
+        default: 'FLOAT(11,12)'
+      });
+
+      testsql('FLOAT(11, 12).UNSIGNED', DataTypes.FLOAT(11, 12).UNSIGNED, {
+        default: 'FLOAT(11,12) UNSIGNED',
+        sqlite: 'FLOAT UNSIGNED(11,12)'
+      });
+
+      testsql('FLOAT(11, 12).UNSIGNED.ZEROFILL', DataTypes.FLOAT(11, 12).UNSIGNED.ZEROFILL, {
+        default: 'FLOAT(11,12) UNSIGNED ZEROFILL',
+        sqlite: 'FLOAT UNSIGNED ZEROFILL(11,12)'
+      });
+
+      testsql('FLOAT(11, 12).ZEROFILL', DataTypes.FLOAT(11, 12).ZEROFILL, {
+        default: 'FLOAT(11,12) ZEROFILL',
+        sqlite: 'FLOAT ZEROFILL(11,12)'
+      });
+
+      testsql('FLOAT(11, 12).ZEROFILL.UNSIGNED', DataTypes.FLOAT(11, 12).ZEROFILL.UNSIGNED, {
+        default: 'FLOAT(11,12) UNSIGNED ZEROFILL',
+        sqlite: 'FLOAT UNSIGNED ZEROFILL(11,12)'
+      });
+
+    });
+
+    suite('DECIMAL', function () {
+      testsql('DECIMAL', DataTypes.DECIMAL, {
+        default: 'DECIMAL'
+      });
+
+      testsql('DECIMAL(10, 2)', DataTypes.DECIMAL(10, 2), {
+        default: 'DECIMAL(10,2)'
+      });
+
+    });
+
+    suite('BLOB', function () {
+      testsql("BLOB", DataTypes.BLOB, {
+        default: 'BLOB',
+        mssql: 'VARBINARY(MAX)',
+        postgres: 'BYTEA'
+      });
+
+      testsql("BLOB('tiny')", DataTypes.BLOB('tiny'), {
+        default: 'TINYBLOB',
+        mssql: 'VARBINARY(MAX)',
+        postgres: 'BYTEA'
+      });
+
+      testsql("BLOB('medium')", DataTypes.BLOB('medium'), {
+        default: 'MEDIUMBLOB',
+        mssql: 'VARBINARY(MAX)',
+        postgres: 'BYTEA'
+      });
+
+      testsql("BLOB('long')", DataTypes.BLOB('long'), {
+        default: 'LONGBLOB',
+        mssql: 'VARBINARY(MAX)',
+        postgres: 'BYTEA'
+      });
+    });
+  });
+});
\ No newline at end of file