treat sqlite

lib/query-interface.js

@@ -223,35 +223,46 @@ module.exports = (function() {
   QueryInterface.prototype.dropAllTables = function() {
   QueryInterface.prototype.dropAllTables = function() {
     var self = this
     var self = this
 
 
-    return new Utils.CustomEventEmitter(function(emitter) {
-      var chainer = new Utils.QueryChainer()
+    if (this.sequelize.options.dialect === 'sqlite') {
+      // sqlite needs some special treatment as it cannot drop a column
+      return SQLiteQueryInterface.dropAllTables.call(this)
+    } else {
+      return new Utils.CustomEventEmitter(function(dropAllTablesEmitter) {
+        var events  = []
+          , chainer = new Utils.QueryChainer()
+          , onError = function(err) {
+              self.emit('dropAllTables', err)
+              dropAllTablesEmitter.emit('error', err)
+            }
 
 
         self.showAllTables().success(function(tableNames) {
         self.showAllTables().success(function(tableNames) {
-          chainer.add(self, 'disableForeignKeyConstraints', [])
+          self.getForeignKeysForTables(tableNames).success(function(foreignKeys) {
 
 
-          tableNames.forEach(function(tableName) {
-            chainer.add(self, 'dropTable', [tableName, {cascade: true}])
+            // add the foreign key removal query to the chainer
+            Object.keys(foreignKeys).forEach(function(tableName) {
+              foreignKeys[tableName].forEach(function(foreignKey) {
+                var sql = self.QueryGenerator.dropForeignKeyQuery(tableName, foreignKey)
+                chainer.add(self.sequelize, 'query', [ sql ])
+              })
             })
             })
 
 
-          chainer.add(self, 'enableForeignKeyConstraints', [])
+            // add the table removal query to the chainer
+            tableNames.forEach(function(tableName) {
+              chainer.add(self, 'dropTable', [ tableName, { cascade: true } ])
+            })
 
 
             chainer
             chainer
               .runSerially()
               .runSerially()
               .success(function() {
               .success(function() {
                 self.emit('dropAllTables', null)
                 self.emit('dropAllTables', null)
-              emitter.emit('success', null)
-            })
-            .error(function(err) {
-              self.emit('dropAllTables', err)
-              emitter.emit('error', err)
-            })
-
-      }).error(function(err) {
-        self.emit('dropAllTables', err)
-        emitter.emit('error', err)
+                dropAllTablesEmitter.emit('success', null)
               })
               })
+              .error(onError)
+          }).error(onError)
+        }).error(onError)
       }).run()
       }).run()
     }
     }
+  }
 
 
   QueryInterface.prototype.renameTable = function(before, after) {
   QueryInterface.prototype.renameTable = function(before, after) {
     var sql = this.QueryGenerator.renameTableQuery(before, after)
     var sql = this.QueryGenerator.renameTableQuery(before, after)
@@ -263,6 +274,7 @@ module.exports = (function() {
 
 
     return new Utils.CustomEventEmitter(function(emitter) {
     return new Utils.CustomEventEmitter(function(emitter) {
       var showTablesSql = self.QueryGenerator.showTablesQuery()
       var showTablesSql = self.QueryGenerator.showTablesQuery()
+
       self.sequelize.query(showTablesSql, null, { raw: true }).success(function(tableNames) {
       self.sequelize.query(showTablesSql, null, { raw: true }).success(function(tableNames) {
         self.emit('showAllTables', null)
         self.emit('showAllTables', null)
         emitter.emit('success', Utils._.flatten(tableNames))
         emitter.emit('success', Utils._.flatten(tableNames))
@@ -397,6 +409,35 @@ module.exports = (function() {
     return queryAndEmit.call(this, sql, 'showIndex')
     return queryAndEmit.call(this, sql, 'showIndex')
   }
   }
 
 
+  QueryInterface.prototype.getForeignKeysForTables = function(tableNames) {
+    var self = this
+
+    return new Utils.CustomEventEmitter(function(emitter) {
+      if (tableNames.length === 0) {
+        emitter.emit('success', {})
+      } else {
+        var chainer = new Utils.QueryChainer()
+
+        tableNames.forEach(function(tableName) {
+          var sql = self.QueryGenerator.getForeignKeysQuery(tableName, self.sequelize.config.database)
+          chainer.add(self.sequelize, 'query', [sql])
+        })
+
+        chainer.runSerially().proxy(emitter, {
+          skipEvents: ['success']
+        }).success(function(results) {
+          var result = {}
+
+          tableNames.forEach(function(tableName, i) {
+            result[tableName] = Utils._.compact(results[i]).map(function(r) { return r.constraint_name })
+          })
+
+          emitter.emit('success', result)
+        })
+      }
+    }).run()
+  }
+
   QueryInterface.prototype.removeIndex = function(tableName, indexNameOrAttributes) {
   QueryInterface.prototype.removeIndex = function(tableName, indexNameOrAttributes) {
     var sql = this.QueryGenerator.removeIndexQuery(tableName, indexNameOrAttributes)
     var sql = this.QueryGenerator.removeIndexQuery(tableName, indexNameOrAttributes)
     return queryAndEmit.call(this, sql, "removeIndex")
     return queryAndEmit.call(this, sql, "removeIndex")
@@ -439,7 +480,7 @@ module.exports = (function() {
       chainer.runSerially()
       chainer.runSerially()
       .success(function(results){
       .success(function(results){
         emitter.query = { sql: sql }
         emitter.query = { sql: sql }
-        emitter.emit('success', results[1])
+        emitter.emit('success', results[0])
         emitter.emit('sql', sql)
         emitter.emit('sql', sql)
       })
       })
       .error(function(err) {
       .error(function(err) {