Merge pull request #5227 from sushantdhiman/fix-966

Fix 966

changelog.md

 # Future
+- [FIXED] Migrations failed to add foreign key [#966](https://github.com/sequelize/sequelize/issues/966)
 - [FIXED] Prevent race condition after transaction finished [#5222](https://github.com/sequelize/sequelize/issues/5222)
 - [FIXED] Fixed Instance.reload issues ([#4844](https://github.com/sequelize/sequelize/issues/4844) and [#4452](https://github.com/sequelize/sequelize/issues/4452))
 - [FIXED] Fix upsert when primary key contains `.field` (internal API change for `queryInterface.upsert`) [#4755](https://github.com/sequelize/sequelize/issues/4755)

lib/dialects/mssql/query-generator.js

@@ -178,21 +178,37 @@ var QueryGenerator = {
   },
 
   changeColumnQuery: function(tableName, attributes) {
-    var query = 'ALTER TABLE <%= tableName %> ALTER COLUMN <%= attributes %>;';
-    var attrString = [];
-
-    for (var attrName in attributes) {
-      var definition = attributes[attrName];
-
+    var query = 'ALTER TABLE <%= tableName %> <%= query %>;';
+    var attrString = [], constraintString = [];
+
+    for (var attributeName in attributes) {
+      var definition = attributes[attributeName];
+      if (definition.match(/REFERENCES/)) {
+        constraintString.push(Utils._.template('<%= fkName %> FOREIGN KEY (<%= attrName %>) <%= definition %>')({
+          fkName: this.quoteIdentifier(attributeName + '_foreign_idx'),
+          attrName: this.quoteIdentifier(attributeName),
+          definition: definition.replace(/.+?(?=REFERENCES)/,'')
+        }));
+      } else {
         attrString.push(Utils._.template('<%= attrName %> <%= definition %>')({
-        attrName: this.quoteIdentifier(attrName),
+          attrName: this.quoteIdentifier(attributeName),
           definition: definition
         }));
       }
+    }
+
+    var finalQuery = '';
+    if (attrString.length) {
+      finalQuery += 'ALTER COLUMN ' + attrString.join(', ');
+      finalQuery += constraintString.length ? ' ' : '';
+    }
+    if (constraintString.length) {
+      finalQuery += 'ADD CONSTRAINT ' + constraintString.join(', ');
+    }
 
     return Utils._.template(query)({
       tableName: this.quoteTable(tableName),
-      attributes: attrString.join(', ')
+      query: finalQuery
     });
   },
 

lib/dialects/mysql/query-generator.js

@@ -121,19 +121,38 @@ var QueryGenerator = {
   },
 
   changeColumnQuery: function(tableName, attributes) {
-    var query = 'ALTER TABLE <%= tableName %> CHANGE <%= attributes %>;';
-    var attrString = [];
-
-    for (var attrName in attributes) {
-      var definition = attributes[attrName];
-
+    var query = 'ALTER TABLE <%= tableName %> <%= query %>;';
+    var attrString = [], constraintString = [];
+
+    for (var attributeName in attributes) {
+      var definition = attributes[attributeName];
+      if (definition.match(/REFERENCES/)) {
+        constraintString.push(Utils._.template('<%= fkName %> FOREIGN KEY (<%= attrName %>) <%= definition %>')({
+          fkName: this.quoteIdentifier(attributeName + '_foreign_idx'),
+          attrName: this.quoteIdentifier(attributeName),
+          definition: definition.replace(/.+?(?=REFERENCES)/,'')
+        }));
+      } else {
         attrString.push(Utils._.template('`<%= attrName %>` `<%= attrName %>` <%= definition %>')({
-        attrName: attrName,
+          attrName: attributeName,
           definition: definition
         }));
       }
+    }
 
-    return Utils._.template(query)({ tableName: this.quoteTable(tableName), attributes: attrString.join(', ') });
+    var finalQuery = '';
+    if (attrString.length) {
+      finalQuery += 'CHANGE ' + attrString.join(', ');
+      finalQuery += constraintString.length ? ' ' : '';
+    }
+    if (constraintString.length) {
+      finalQuery += 'ADD CONSTRAINT ' + constraintString.join(', ');
+    }
+
+    return Utils._.template(query)({
+      tableName: this.quoteTable(tableName),
+      query: finalQuery
+    });
   },
 
   renameColumnQuery: function(tableName, attrBefore, attributes) {

lib/dialects/postgres/query-generator.js

@@ -221,7 +221,7 @@ var QueryGenerator = {
         });
 
         definition = definition.replace('NOT NULL', '').trim();
-      } else {
+      } else if (!definition.match(/REFERENCES/)) {
         attrSql += Utils._.template(query)({
           tableName: this.quoteTable(tableName),
           query: this.quoteIdentifier(attributeName) + ' DROP NOT NULL'
@@ -235,7 +235,7 @@ var QueryGenerator = {
         });
 
         definition = definition.replace(/(DEFAULT[^;]+)/, '').trim();
-      } else {
+      } else if (!definition.match(/REFERENCES/)) {
         attrSql += Utils._.template(query)({
           tableName: this.quoteTable(tableName),
           query: this.quoteIdentifier(attributeName) + ' DROP DEFAULT'
@@ -257,10 +257,18 @@ var QueryGenerator = {
         });
       }
 
+      if (definition.match(/REFERENCES/)) {
+        definition = definition.replace(/.+?(?=REFERENCES)/,'');
+        attrSql += Utils._.template(query.replace('ALTER COLUMN', ''))({
+          tableName: this.quoteTable(tableName),
+          query: 'ADD CONSTRAINT ' + this.quoteIdentifier(attributeName + '_foreign_idx') + ' FOREIGN KEY (' + this.quoteIdentifier(attributeName) + ') ' + definition
+        });
+      } else {
         attrSql += Utils._.template(query)({
           tableName: this.quoteTable(tableName),
           query: this.quoteIdentifier(attributeName) + ' TYPE ' + definition
         });
+      }
 
       sql.push(attrSql);
     }

test/integration/query-interface.test.js

@@ -410,6 +410,73 @@ describe(Support.getTestDialectTeaser('QueryInterface'), function() {
         });
       });
     });
+
+    it('should change columns', function() {
+        return this.queryInterface.createTable({
+          tableName: 'users',
+        }, {
+          id: {
+            type: DataTypes.INTEGER,
+            primaryKey: true,
+            autoIncrement: true
+          },
+          currency: DataTypes.INTEGER
+        }).bind(this).then(function() {
+          return this.queryInterface.changeColumn('users', 'currency', {
+            type: DataTypes.FLOAT,
+            allowNull: true
+          }, {
+            logging: log
+          }).then(function() {
+            expect(count).to.be.equal(1);
+            count = 0;
+          });
+        });
+    });
+
+    //SQlite navitely doesnt support ALTER Foreign key
+    if (dialect !== 'sqlite') {
+      describe('should support foreign keys', function() {
+        beforeEach(function() {
+          return this.queryInterface.createTable('users', {
+            id: {
+              type: DataTypes.INTEGER,
+              primaryKey: true,
+              autoIncrement: true
+            },
+            level_id: {
+              type: DataTypes.INTEGER,
+              allowNull: false
+            }
+          })
+          .bind(this).then(function() {
+            return this.queryInterface.createTable('level', {
+              id: {
+                type: DataTypes.INTEGER,
+                primaryKey: true,
+                autoIncrement: true
+              }
+            });
+          });
+        });
+
+        it('able to change column to foreign key', function() {
+          return this.queryInterface.changeColumn('users', 'level_id', {
+            type: DataTypes.INTEGER,
+            references: {
+              model: 'level',
+              key:   'id'
+            },
+            onUpdate: 'cascade',
+            onDelete: 'cascade'
+          }, {logging: log}).then(function() {
+            expect(count).to.be.equal(1);
+            count = 0;
+          });
+        });
+
+      });
+    }
   });
 
   describe('addColumn', function() {

test/unit/sql/change-column.test.js

+'use strict';
+
+/* jshint -W030, -W110 */
+var Support   = require(__dirname + '/../support')
+  , DataTypes = require('../../../lib/data-types')
+  , expectsql = Support.expectsql
+  , sinon = require('sinon')
+  , current   = Support.sequelize
+  , Promise = current.Promise;
+
+
+if (current.dialect.name !== 'sqlite') {
+  describe(Support.getTestDialectTeaser('SQL'), function() {
+    describe('changeColumn', function () {
+
+      var Model = current.define('users', {
+        id: {
+          type: DataTypes.INTEGER,
+          primaryKey: true,
+          autoIncrement: true
+        },
+        level_id: {
+          type: DataTypes.INTEGER
+        }
+      }, { timestamps: false });
+
+      before(function () {
+
+        this.stub = sinon.stub(current, 'query', function (sql) {
+          return Promise.resolve(sql);
+        });
+      });
+
+      beforeEach(function () {
+        this.stub.reset();
+      });
+
+      after(function () {
+        this.stub.restore();
+      });
+
+      it('properly generate alter queries', function(){
+        return current.getQueryInterface().changeColumn(Model.getTableName(), 'level_id', {
+          type: DataTypes.FLOAT,
+          allowNull: false,
+        }).then(function(sql){
+          expectsql(sql, {
+            mssql: 'ALTER TABLE [users] ALTER COLUMN [level_id] FLOAT NOT NULL;',
+            mysql: 'ALTER TABLE `users` CHANGE `level_id` `level_id` FLOAT NOT NULL;',
+            postgres: 'ALTER TABLE "users" ALTER COLUMN "level_id" SET NOT NULL;ALTER TABLE "users" ALTER COLUMN "level_id" DROP DEFAULT;ALTER TABLE "users" ALTER COLUMN "level_id" TYPE FLOAT;',
+          });
+        });
+      });
+
+      it('properly generate alter queries for foreign keys', function(){
+        return current.getQueryInterface().changeColumn(Model.getTableName(), 'level_id', {
+          type: DataTypes.INTEGER,
+          references: {
+            model: 'level',
+            key:   'id'
+          },
+          onUpdate: 'cascade',
+          onDelete: 'cascade'
+        }).then(function(sql){
+          expectsql(sql, {
+            mssql: 'ALTER TABLE [users] ADD CONSTRAINT [level_id_foreign_idx] FOREIGN KEY ([level_id]) REFERENCES [level] ([id]) ON DELETE CASCADE;',
+            mysql: 'ALTER TABLE `users` ADD CONSTRAINT `level_id_foreign_idx` FOREIGN KEY (`level_id`) REFERENCES `level` (`id`) ON DELETE CASCADE ON UPDATE CASCADE;',
+            postgres: 'ALTER TABLE "users"  ADD CONSTRAINT "level_id_foreign_idx" FOREIGN KEY ("level_id") REFERENCES "level" ("id") ON DELETE CASCADE ON UPDATE CASCADE;',
+          });
+        });
+      });
+
+    });
+  });
+}