Merge pull request #569 from optilude/master

Support for bulk insert, update and delete operations at the DAOFactory level

changelog.md

@@ -6,6 +6,7 @@
 - [BUG] Null dates don't break SQLite anymore. [#572](https://github.com/sequelize/sequelize/pull/572). thanks to mweibel
 - [FEATURE] Schematics. [#564](https://github.com/sequelize/sequelize/pull/564). thanks to durango
 - [FEATURE] Foreign key constraints. [#595](https://github.com/sequelize/sequelize/pull/595). thanks to optilude
+- [FEATURE] Support for bulk insert (`<DAOFactory>.bulkCreate()`, update (`<DAOFactory>`.update()`) and delete (`<DAOFactory>`.destroy()`)
 
 # v1.6.0 #
 - [DEPENDENCIES] upgrade mysql to alpha7. You *MUST* use this version or newer for DATETIMEs to work

lib/dao-factory.js

@@ -328,6 +328,110 @@ module.exports = (function() {
     }).run()
   }
 
+  /**
+   * Create and insert multiple instances
+   *
+   * @param  {Array} records List of objects (key/value pairs) to create instances from
+   * @param  {Array} fields Fields to insert (defaults to all fields)
+   * @return {Object}       A promise which fires `success`, `error`, `complete` and `sql`.
+   *
+   * Note: the `success` handler is not passed any arguments. To obtain DAOs for
+   * the newly created values, you will need to query for them again. This is
+   * because MySQL and SQLite do not make it easy to obtain back automatically
+   * generated IDs and other default values in a way that can be mapped to
+   * multiple records
+   */
+  DAOFactory.prototype.bulkCreate = function(records, fields) {
+    var self          = this
+      , daos          = records.map(function(v) { return self.build(v) })
+      , updatedAtAttr = self.options.underscored ? 'updated_at' : 'updatedAt'
+      , createdAtAttr = self.options.underscored ? 'created_at' : 'createdAt'
+
+    // we will re-create from DAOs, which may have set up default attributes
+    records = []
+
+    if (fields) {
+
+      // Always insert updated and created time stamps
+      if (self.options.timestamps) {
+        if (fields.indexOf(updatedAtAttr) === -1) {
+          fields.push(updatedAtAttr)
+        }
+
+        if (fields.indexOf(createdAtAttr) === -1) {
+          fields.push(createdAtAttr)
+        }
+      }
+
+      // Build records for the fields we know about
+      daos.forEach(function(dao) {
+        var values = {};
+        fields.forEach(function(field) {
+          values[field] = dao.values[field]
+        })
+        if (self.options.timestamps) {
+          values[updatedAtAttr] = Utils.now()
+        }
+        records.push(values);
+      })
+
+    } else {
+      daos.forEach(function(dao) {
+        records.push(dao.values)
+      })
+    }
+
+    // Validate enums
+    records.forEach(function(values) {
+      for (var attrName in self.rawAttributes) {
+        if (self.rawAttributes.hasOwnProperty(attrName)) {
+          var definition      = self.rawAttributes[attrName]
+            , isEnum          = (definition.type && (definition.type.toString() === DataTypes.ENUM.toString()))
+            , hasValue        = (typeof values[attrName] !== 'undefined')
+            , valueOutOfScope = ((definition.values || []).indexOf(values[attrName]) === -1)
+
+          if (isEnum && hasValue && valueOutOfScope) {
+            throw new Error('Value "' + values[attrName] + '" for ENUM ' + attrName + ' is out of allowed scope. Allowed values: ' + definition.values.join(', '))
+          }
+        }
+      }
+    })
+
+    return self.QueryInterface.bulkInsert(self.tableName, records)
+  }
+
+  /**
+   * Delete multiple instances
+   *
+   * @param  {Object} where   Options to describe the scope of the search.
+   * @return {Object}         A promise which fires `success`, `error`, `complete` and `sql`.
+   */
+  DAOFactory.prototype.destroy = function(where) {
+    if (this.options.timestamps && this.options.paranoid) {
+      var attr = this.options.underscored ? 'deleted_at' : 'deletedAt'
+      var attrValueHash = {}
+      attrValueHash[attr] = Utils.now()
+      return this.QueryInterface.bulkUpdate(this.tableName, attrValueHash, where)
+    } else {
+      return this.QueryInterface.bulkDelete(this.tableName, where)
+    }
+  }
+
+  /**
+   * Update multiple instances
+   *
+   * @param  {Object} attrValueHash A hash of fields to change and their new values
+   * @param  {Object} where         Options to describe the scope of the search.
+   * @return {Object}               A promise which fires `success`, `error`, `complete` and `sql`.
+   */
+  DAOFactory.prototype.update = function(attrValueHash, where) {
+    if(this.options.timestamps) {
+      var attr = this.options.underscored ? 'updated_at' : 'updatedAt'
+      attrValueHash[attr] = Utils.now()
+    }
+    return this.QueryInterface.bulkUpdate(this.tableName, attrValueHash, where)
+  }
+
   // private
 
   var query = function() {

lib/dialects/mysql/query-generator.js

@@ -243,6 +243,25 @@ module.exports = (function() {
       return query
     },
 
+    bulkInsertQuery: function(tableName, attrValueHashes) {
+      var tuples = []
+
+      Utils._.forEach(attrValueHashes, function(attrValueHash) {
+        tuples.push("(" +
+          Utils._.values(attrValueHash).map(function(value){
+            return Utils.escape((value instanceof Date) ? Utils.toSqlDate(value) : value)
+          }).join(",") +
+        ")")
+      })
+
+      var table      = QueryGenerator.addQuotes(tableName)
+      var attributes = Object.keys(attrValueHashes[0]).map(function(attr){return QueryGenerator.addQuotes(attr)}).join(",")
+
+      var query  = "INSERT INTO " + table + " (" + attributes + ") VALUES " + tuples.join(",") + ";"
+
+      return query
+    },
+
     updateQuery: function(tableName, attrValueHash, where) {
       attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
 
@@ -264,13 +283,31 @@ module.exports = (function() {
 
     deleteQuery: function(tableName, where, options) {
       options = options || {}
-      options.limit = options.limit || 1
 
       var table = QueryGenerator.addQuotes(tableName)
       var where = QueryGenerator.getWhereConditions(where)
-      var limit = Utils.escape(options.limit)
+      var limit = ""
+
+      if(Utils._.isUndefined(options.limit)) {
+        options.limit = 1;
+      }
+
+      if(!!options.limit) {
+        limit = " LIMIT " + Utils.escape(options.limit)
+      }
 
-      var query = "DELETE FROM " + table + " WHERE " + where + " LIMIT " + limit
+      var query = "DELETE FROM " + table + " WHERE " + where + limit
+
+      return query
+    },
+
+    bulkDeleteQuery: function(tableName, where, options) {
+      options = options || {}
+
+      var table = QueryGenerator.addQuotes(tableName)
+      var where = QueryGenerator.getWhereConditions(where)
+
+      var query = "DELETE FROM " + table + " WHERE " + where
 
       return query
     },
@@ -286,7 +323,7 @@ module.exports = (function() {
 
         values.push(QueryGenerator.addQuotes(key) + "=" + QueryGenerator.addQuotes(key) + " + " +Utils.escape(_value))
       }
-      
+
       var table = QueryGenerator.addQuotes(tableName)
       var values =  values.join(",")
       var where = QueryGenerator.getWhereConditions(where)

lib/dialects/postgres/query-generator.js

@@ -301,18 +301,7 @@ module.exports = (function() {
       attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
 
       var query     = "INSERT INTO <%= table %> (<%= attributes %>) VALUES (<%= values %>) RETURNING *;"
-        , returning = []
-
-      Utils._.forEach(attrValueHash, function(value, key, hash) {
-        if (tables[tableName] && tables[tableName][key]) {
-          switch (tables[tableName][key]) {
-            case 'serial':
-              delete hash[key]
-              returning.push(key)
-              break
-          }
-        }
-      });
+        , returning = removeSerialsFromHash(tableName, attrValueHash)
 
       var replacements  = {
         table:      QueryGenerator.addQuotes(tableName)
@@ -327,6 +316,30 @@ module.exports = (function() {
       return Utils._.template(query)(replacements)
     },
 
+    bulkInsertQuery: function(tableName, attrValueHashes) {
+      var query     = "INSERT INTO <%= table %> (<%= attributes %>) VALUES <%= tuples %> RETURNING *;"
+        , tuples    = []
+
+      Utils._.forEach(attrValueHashes, function(attrValueHash) {
+        removeSerialsFromHash(tableName, attrValueHash)
+        tuples.push("(" +
+          Utils._.values(attrValueHash).map(function(value){
+            return QueryGenerator.pgEscape(value)
+          }).join(",") +
+        ")")
+      })
+
+      var replacements  = {
+        table:      QueryGenerator.addQuotes(tableName)
+      , attributes: Object.keys(attrValueHashes[0]).map(function(attr){
+                      return QueryGenerator.addQuotes(attr)
+                    }).join(",")
+      , tuples:     tuples.join(",")
+      }
+
+      return Utils._.template(query)(replacements)
+    },
+
     updateQuery: function(tableName, attrValueHash, where) {
       attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
 
@@ -349,11 +362,14 @@ module.exports = (function() {
 
     deleteQuery: function(tableName, where, options) {
       options = options || {}
-      options.limit = options.limit || 1
+
+      if(Utils._.isUndefined(options.limit)) {
+        options.limit = 1;
+      }
 
       primaryKeys[tableName] = primaryKeys[tableName] || [];
 
-      var query = "DELETE FROM <%= table %> WHERE <%= primaryKeys %> IN (SELECT <%= primaryKeysSelection %> FROM <%= table %> WHERE <%= where %> LIMIT <%= limit %>)"
+      var query = "DELETE FROM <%= table %> WHERE <%= primaryKeys %> IN (SELECT <%= primaryKeysSelection %> FROM <%= table %> WHERE <%= where %><%= limit %>)"
 
       var pks;
       if (primaryKeys[tableName] && primaryKeys[tableName].length > 0) {
@@ -367,7 +383,7 @@ module.exports = (function() {
       var replacements = {
         table: QueryGenerator.addQuotes(tableName),
         where: QueryGenerator.getWhereConditions(where),
-        limit: QueryGenerator.pgEscape(options.limit),
+        limit: !!options.limit? " LIMIT " + QueryGenerator.pgEscape(options.limit) : "",
         primaryKeys: primaryKeys[tableName].length > 1 ? '(' + pks + ')' : pks,
         primaryKeysSelection: pks
       }
@@ -721,5 +737,22 @@ module.exports = (function() {
     }
   }
 
+  // Private
+
+  var removeSerialsFromHash = function(tableName, attrValueHash) {
+    var returning = [];
+    Utils._.forEach(attrValueHash, function(value, key, hash) {
+        if (tables[tableName] && tables[tableName][key]) {
+          switch (tables[tableName][key]) {
+            case 'serial':
+              delete hash[key]
+              returning.push(key)
+              break
+          }
+        }
+      });
+    return returning;
+  }
+
   return Utils._.extend(Utils._.clone(require("../query-generator")), QueryGenerator)
 })()

lib/dialects/postgres/query.js

@@ -108,27 +108,29 @@ module.exports = (function() {
     } else if (this.send('isShowOrDescribeQuery')) {
       this.emit('success', results)
     } else if (this.send('isInsertQuery')) {
-      for (var key in rows[0]) {
-        if (rows[0].hasOwnProperty(key)) {
-          var record = rows[0][key]
-          if (!!this.callee.daoFactory.rawAttributes[key].type && !!this.callee.daoFactory.rawAttributes[key].type.type && this.callee.daoFactory.rawAttributes[key].type.type === DataTypes.HSTORE.type) {
-            record = this.callee.daoFactory.daoFactoryManager.sequelize.queryInterface.QueryGenerator.toHstore(record)
+      if(this.callee !== null) { // may happen for bulk inserts
+        for (var key in rows[0]) {
+          if (rows[0].hasOwnProperty(key)) {
+            var record = rows[0][key]
+            if (!!this.callee.daoFactory.rawAttributes[key].type && !!this.callee.daoFactory.rawAttributes[key].type.type && this.callee.daoFactory.rawAttributes[key].type.type === DataTypes.HSTORE.type) {
+              record = this.callee.daoFactory.daoFactoryManager.sequelize.queryInterface.QueryGenerator.toHstore(record)
+            }
+            this.callee[key] = record
           }
-
-          this.callee[key] = record
         }
       }
 
       this.emit('success', this.callee)
     } else if (this.send('isUpdateQuery')) {
-      for (var key in rows[0]) {
-        if (rows[0].hasOwnProperty(key)) {
-          var record = rows[0][key]
-          if (!!this.callee.daoFactory.rawAttributes[key].type && !!this.callee.daoFactory.rawAttributes[key].type.type && this.callee.daoFactory.rawAttributes[key].type.type === DataTypes.HSTORE.type) {
-            record = this.callee.daoFactory.daoFactoryManager.sequelize.queryInterface.QueryGenerator.toHstore(record)
+      if(this.callee !== null) { // may happen for bulk updates
+        for (var key in rows[0]) {
+          if (rows[0].hasOwnProperty(key)) {
+            var record = rows[0][key]
+            if (!!this.callee.daoFactory.rawAttributes[key].type && !!this.callee.daoFactory.rawAttributes[key].type.type && this.callee.daoFactory.rawAttributes[key].type.type === DataTypes.HSTORE.type) {
+              record = this.callee.daoFactory.daoFactoryManager.sequelize.queryInterface.QueryGenerator.toHstore(record)
+            }
+            this.callee[key] = record
           }
-
-          this.callee[key] = record
         }
       }
 

lib/dialects/query-generator.js

@@ -119,6 +119,14 @@ module.exports = (function() {
     },
 
     /*
+      Returns an insert into command for multiple values.
+      Parameters: table name + list of hashes of attribute-value-pairs.
+    */
+    bulkInsertQuery: function(tableName, attrValueHashes) {
+      throwMethodUndefined('bulkInsertQuery')
+    },
+
+    /*
       Returns an update query.
       Parameters:
         - tableName -> Name of the table
@@ -148,6 +156,19 @@ module.exports = (function() {
     },
 
     /*
+      Returns a bulk deletion query.
+      Parameters:
+        - tableName -> Name of the table
+        - where -> A hash with conditions (e.g. {name: 'foo'})
+                   OR an ID as integer
+                   OR a string with conditions (e.g. 'name="foo"').
+                   If you use a string, you have to escape it on your own.
+    */
+    bulkDeleteQuery: function(tableName, where, options) {
+      throwMethodUndefined('bulkDeleteQuery')
+    },
+
+    /*
       Returns an update query.
       Parameters:
         - tableName -> Name of the table

lib/dialects/sqlite/query-generator.js

@@ -125,6 +125,27 @@ module.exports = (function() {
       return Utils._.template(query)(replacements)
     },
 
+    bulkInsertQuery: function(tableName, attrValueHashes) {
+      var query = "INSERT INTO <%= table %> (<%= attributes %>) VALUES <%= tuples %>;"
+        , tuples = []
+
+      Utils._.forEach(attrValueHashes, function(attrValueHash) {
+        tuples.push("(" +
+          Utils._.values(attrValueHash).map(function(value){
+            return escape((value instanceof Date) ? Utils.toSqlDate(value) : value)
+          }).join(",") +
+        ")")
+      })
+
+      var replacements  = {
+        table: Utils.addTicks(tableName),
+        attributes: Object.keys(attrValueHashes[0]).map(function(attr){return Utils.addTicks(attr)}).join(","),
+        tuples: tuples
+      }
+
+      return Utils._.template(query)(replacements)
+    },
+
     updateQuery: function(tableName, attrValueHash, where) {
       attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
 
@@ -151,8 +172,7 @@ module.exports = (function() {
       var query = "DELETE FROM <%= table %> WHERE <%= where %>"
       var replacements = {
         table: Utils.addTicks(tableName),
-        where: this.getWhereConditions(where),
-        limit: Utils.escape(options.limit)
+        where: MySqlQueryGenerator.getWhereConditions(where)
       }
 
       return Utils._.template(query)(replacements)

lib/query-interface.js

@@ -260,16 +260,31 @@ module.exports = (function() {
     })
   }
 
+  QueryInterface.prototype.bulkInsert = function(tableName, records) {
+    var sql = this.QueryGenerator.bulkInsertQuery(tableName, records)
+    return queryAndEmit.call(this, sql, 'bulkInsert')
+  }
+
   QueryInterface.prototype.update = function(dao, tableName, values, identifier) {
     var sql = this.QueryGenerator.updateQuery(tableName, values, identifier)
     return queryAndEmit.call(this, [sql, dao], 'update')
   }
 
+  QueryInterface.prototype.bulkUpdate = function(tableName, values, identifier) {
+    var sql = this.QueryGenerator.updateQuery(tableName, values, identifier)
+    return queryAndEmit.call(this, sql, 'bulkUpdate')
+  }
+
   QueryInterface.prototype.delete = function(dao, tableName, identifier) {
     var sql = this.QueryGenerator.deleteQuery(tableName, identifier)
     return queryAndEmit.call(this, [sql, dao], 'delete')
   }
 
+  QueryInterface.prototype.bulkDelete = function(tableName, identifier) {
+    var sql = this.QueryGenerator.deleteQuery(tableName, identifier, {limit: null})
+    return queryAndEmit.call(this, sql, 'bulkDelete')
+  }
+
   QueryInterface.prototype.select = function(factory, tableName, options, queryOptions) {
     options = options || {}
 

spec-jasmine/mysql/query-generator.spec.js

@@ -200,6 +200,37 @@ describe('QueryGenerator', function() {
       }
     ],
 
+    bulkInsertQuery: [
+      {
+        arguments: ['myTable', [{name: 'foo'}, {name: 'bar'}]],
+        expectation: "INSERT INTO `myTable` (`name`) VALUES ('foo'),('bar');"
+      }, {
+        arguments: ['myTable', [{name: "foo';DROP TABLE myTable;"}, {name: 'bar'}]],
+        expectation: "INSERT INTO `myTable` (`name`) VALUES ('foo\\';DROP TABLE myTable;'),('bar');"
+      }, {
+        arguments: ['myTable', [{name: 'foo', birthday: new Date(Date.UTC(2011, 2, 27, 10, 1, 55))}, {name: 'bar', birthday: new Date(Date.UTC(2012, 2, 27, 10, 1, 55))}]],
+        expectation: "INSERT INTO `myTable` (`name`,`birthday`) VALUES ('foo','2011-03-27 10:01:55'),('bar','2012-03-27 10:01:55');"
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1}, {name: 'bar', foo: 2}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`) VALUES ('foo',1),('bar',2);"
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1, nullValue: null}, {name: 'bar', nullValue: null}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL),('bar',NULL);"
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1, nullValue: null}, {name: 'bar', foo: 2, nullValue: null}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL),('bar',2,NULL);",
+        context: {options: {omitNull: false}}
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1, nullValue: null}, {name: 'bar', foo: 2, nullValue: null}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL),('bar',2,NULL);",
+        context: {options: {omitNull: true}} // Note: We don't honour this because it makes little sense when some rows may have nulls and others not
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1, nullValue: undefined}, {name: 'bar', foo: 2, undefinedValue: undefined}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL),('bar',2,NULL);",
+        context: {options: {omitNull: true}} // Note: As above
+      }
+    ],
+
     updateQuery: [
       {
         arguments: ['myTable', {name: 'foo', birthday: new Date(Date.UTC(2011, 2, 27, 10, 1, 55))}, {id: 2}],
@@ -240,6 +271,9 @@ describe('QueryGenerator', function() {
       }, {
         arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}, {limit: 10}],
         expectation: "DELETE FROM `myTable` WHERE `name`='foo\\';DROP TABLE myTable;' LIMIT 10"
+      }, {
+        arguments: ['myTable', {name: 'foo'}, {limit: null}],
+        expectation: "DELETE FROM `myTable` WHERE `name`='foo'"
       }
     ],
 

spec-jasmine/postgres/query-generator.spec.js

@@ -208,6 +208,46 @@ describe('QueryGenerator', function() {
       }
     ],
 
+    bulkInsertQuery: [
+      {
+        arguments: ['myTable', [{name: 'foo'}, {name: 'bar'}]],
+        expectation: "INSERT INTO \"myTable\" (\"name\") VALUES ('foo'),('bar') RETURNING *;"
+      }, {
+        arguments: ['myTable', [{name: "foo';DROP TABLE myTable;"}, {name: 'bar'}]],
+        expectation: "INSERT INTO \"myTable\" (\"name\") VALUES ('foo'';DROP TABLE myTable;'),('bar') RETURNING *;"
+      }, {
+        arguments: ['myTable', [{name: 'foo', birthday: new Date(Date.UTC(2011, 2, 27, 10, 1, 55))}, {name: 'bar', birthday: new Date(Date.UTC(2012, 2, 27, 10, 1, 55))}]],
+        expectation: "INSERT INTO \"myTable\" (\"name\",\"birthday\") VALUES ('foo','2011-03-27 10:01:55.0Z'),('bar','2012-03-27 10:01:55.0Z') RETURNING *;"
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1}, {name: 'bar', foo: 2}]],
+        expectation: "INSERT INTO \"myTable\" (\"name\",\"foo\") VALUES ('foo',1),('bar',2) RETURNING *;"
+      }, {
+        arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+        expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL),('bar',NULL) RETURNING *;"
+      }, {
+        arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+        expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+        context: {options: {omitNull: false}}
+      }, {
+        arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+        expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+        context: {options: {omitNull: true}} // Note: We don't honour this because it makes little sense when some rows may have nulls and others not
+      }, {
+        arguments: ['myTable', [{name: 'foo', nullValue: undefined}, {name: 'bar', nullValue: undefined}]],
+        expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+        context: {options: {omitNull: true}} // Note: As above
+      }, {
+        arguments: ['mySchema.myTable', [{name: 'foo'}, {name: 'bar'}]],
+        expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('foo'),('bar') RETURNING *;"
+      }, {
+        arguments: ['mySchema.myTable', [{name: JSON.stringify({info: 'Look ma a " quote'})}, {name: JSON.stringify({info: 'Look ma another " quote'})}]],
+        expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('{\"info\":\"Look ma a \\\" quote\"}'),('{\"info\":\"Look ma another \\\" quote\"}') RETURNING *;"
+      }, {
+        arguments: ['mySchema.myTable', [{name: "foo';DROP TABLE mySchema.myTable;"}, {name: 'bar'}]],
+        expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('foo'';DROP TABLE mySchema.myTable;'),('bar') RETURNING *;"
+      }
+    ],
+
     updateQuery: [
       {
         arguments: ['myTable', {name: 'foo', birthday: new Date(Date.UTC(2011, 2, 27, 10, 1, 55))}, {id: 2}],
@@ -264,6 +304,9 @@ describe('QueryGenerator', function() {
       }, {
         arguments: ['mySchema.myTable', {name: "foo';DROP TABLE mySchema.myTable;"}, {limit: 10}],
         expectation: "DELETE FROM \"mySchema\".\"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"mySchema\".\"myTable\" WHERE \"name\"='foo'';DROP TABLE mySchema.myTable;' LIMIT 10)"
+      }, {
+        arguments: ['myTable', {name: 'foo'}, {limit: null}],
+        expectation: "DELETE FROM \"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"myTable\" WHERE \"name\"='foo')"
       }
     ],
 

spec-jasmine/sqlite/query-generator.spec.js

@@ -121,6 +121,43 @@ describe('QueryGenerator', function() {
       }
     ],
 
+    bulkInsertQuery: [
+      {
+        arguments: ['myTable', [{name: 'foo'}, {name: 'bar'}]],
+        expectation: "INSERT INTO `myTable` (`name`) VALUES ('foo'),('bar');"
+      }, {
+        arguments: ['myTable', [{name: "'bar'"}, {name: 'foo'}]],
+        expectation: "INSERT INTO `myTable` (`name`) VALUES ('''bar'''),('foo');"
+      }, {
+        arguments: ['myTable', [{name: "bar", value: null}, {name: 'foo', value: 1}]],
+        expectation: "INSERT INTO `myTable` (`name`,`value`) VALUES ('bar',NULL),('foo',1);"
+      }, {
+        arguments: ['myTable', [{name: "bar", value: undefined}, {name: 'bar', value: 2}]],
+        expectation: "INSERT INTO `myTable` (`name`,`value`) VALUES ('bar',NULL),('bar',2);"
+      }, {
+        arguments: ['myTable', [{name: "foo", value: true}, {name: 'bar', value: false}]],
+        expectation: "INSERT INTO `myTable` (`name`,`value`) VALUES ('foo',1),('bar',0);"
+      }, {
+        arguments: ['myTable', [{name: "foo", value: false}, {name: 'bar', value: false}]],
+        expectation: "INSERT INTO `myTable` (`name`,`value`) VALUES ('foo',0),('bar',0);"
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1, nullValue: null}, {name: 'bar', foo: 2, nullValue: null}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL),('bar',2,NULL);"
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1, nullValue: null}, {name: 'bar', foo: 2, nullValue: null}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL),('bar',2,NULL);",
+        context: {options: {omitNull: false}}
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1, nullValue: null}, {name: 'bar', foo: 2, nullValue: null}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL),('bar',2,NULL);",
+        context: {options: {omitNull: true}} // Note: We don't honour this because it makes little sense when some rows may have nulls and others not
+      }, {
+        arguments: ['myTable', [{name: 'foo', foo: 1, nullValue: null}, {name: 'bar', foo: 2, nullValue: null}]],
+        expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL),('bar',2,NULL);",
+        context: {options: {omitNull: true}} // Note: As above
+      }
+    ],
+
     updateQuery: [
       {
         arguments: ['myTable', { name: 'foo' }, { id: 2 }],
@@ -152,6 +189,25 @@ describe('QueryGenerator', function() {
         expectation: "UPDATE `myTable` SET `bar`=2 WHERE `name`='foo'",
         context: {options: {omitNull: true}}
       }
+    ],
+
+    deleteQuery: [
+      {
+        arguments: ['myTable', {name: 'foo'}],
+        expectation: "DELETE FROM `myTable` WHERE `name`='foo'"
+      }, {
+        arguments: ['myTable', 1],
+        expectation: "DELETE FROM `myTable` WHERE `id`=1"
+      }, {
+        arguments: ['myTable', 1, {limit: 10}],
+        expectation: "DELETE FROM `myTable` WHERE `id`=1"
+      }, {
+        arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}, {limit: 10}],
+        expectation: "DELETE FROM `myTable` WHERE `name`='foo\\';DROP TABLE myTable;'"
+      }, {
+        arguments: ['myTable', {name: 'foo'}, {limit: null}],
+        expectation: "DELETE FROM `myTable` WHERE `name`='foo'"
+      }
     ]
   };
 

spec/dao-factory.spec.js

@@ -387,6 +387,276 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
     })
   })
 
+  describe('bulkCreate', function() {
+
+    it('inserts multiple values respecting the white list', function(done) {
+      var self = this
+        , data = [{ username: 'Peter', secretValue: '42' },
+                  { username: 'Paul', secretValue: '23'}]
+
+      this.User.bulkCreate(data, ['username']).success(function() {
+        self.User.findAll({order: 'id'}).success(function(users) {
+          expect(users.length).toEqual(2)
+
+          expect(users[0].username).toEqual("Peter")
+          expect(users[0].secretValue).toBeNull();
+
+          expect(users[1].username).toEqual("Paul")
+          expect(users[1].secretValue).toBeNull();
+
+          done()
+        })
+      })
+    })
+
+    it('should store all values if no whitelist is specified', function(done) {
+      var self = this
+        , data = [{ username: 'Peter', secretValue: '42' },
+                  { username: 'Paul', secretValue: '23'}]
+
+      this.User.bulkCreate(data).success(function() {
+        self.User.findAll({order: 'id'}).success(function(users) {
+          expect(users.length).toEqual(2)
+
+          expect(users[0].username).toEqual("Peter")
+          expect(users[0].secretValue).toEqual('42')
+
+          expect(users[1].username).toEqual("Paul")
+          expect(users[1].secretValue).toEqual('23')
+
+          done()
+        })
+      })
+    })
+
+    it('saves data with single quote', function(done) {
+      var self = this
+        , quote = "Single'Quote"
+        , data = [{ username: 'Peter', data: quote},
+                  { username: 'Paul', data: quote}]
+
+      this.User.bulkCreate(data).success(function() {
+        self.User.findAll({order: 'id'}).success(function(users) {
+          expect(users.length).toEqual(2)
+
+          expect(users[0].username).toEqual("Peter")
+          expect(users[0].data).toEqual(quote)
+
+          expect(users[1].username).toEqual("Paul")
+          expect(users[1].data).toEqual(quote)
+
+          done()
+        })
+      })
+    })
+
+    it('saves data with double quote', function(done) {
+      var self = this
+        , quote = 'Double"Quote'
+        , data = [{ username: 'Peter', data: quote},
+                  { username: 'Paul', data: quote}]
+
+      this.User.bulkCreate(data).success(function() {
+        self.User.findAll({order: 'id'}).success(function(users) {
+          expect(users.length).toEqual(2)
+
+          expect(users[0].username).toEqual("Peter")
+          expect(users[0].data).toEqual(quote)
+
+          expect(users[1].username).toEqual("Paul")
+          expect(users[1].data).toEqual(quote)
+
+          done()
+        })
+      })
+    })
+
+    it('saves stringified JSON data', function(done) {
+      var self = this
+        , json = JSON.stringify({ key: 'value' })
+        , data = [{ username: 'Peter', data: json},
+                  { username: 'Paul', data: json}]
+
+      this.User.bulkCreate(data).success(function() {
+        self.User.findAll({order: 'id'}).success(function(users) {
+          expect(users.length).toEqual(2)
+
+          expect(users[0].username).toEqual("Peter")
+          expect(users[0].data).toEqual(json)
+
+          expect(users[1].username).toEqual("Paul")
+          expect(users[1].data).toEqual(json)
+
+          done()
+        })
+      })
+    })
+
+    it('stores the current date in createdAt', function(done) {
+      var self = this
+        , data = [{ username: 'Peter'},
+                  { username: 'Paul'}]
+
+      this.User.bulkCreate(data).success(function() {
+        self.User.findAll({order: 'id'}).success(function(users) {
+          expect(users.length).toEqual(2)
+
+          expect(users[0].username).toEqual("Peter")
+          expect(parseInt(+users[0].createdAt/5000)).toEqual(parseInt(+new Date()/5000))
+
+          expect(users[1].username).toEqual("Paul")
+          expect(parseInt(+users[1].createdAt/5000)).toEqual(parseInt(+new Date()/5000))
+
+          done()
+        })
+      })
+    })
+
+    describe('enums', function() {
+      before(function(done) {
+        this.Item = this.sequelize.define('Item', {
+          state: { type: Helpers.Sequelize.ENUM, values: ['available', 'in_cart', 'shipped'] },
+          name: Sequelize.STRING
+        })
+
+        this.sequelize.sync({ force: true }).success(function() {
+          this.Item.bulkCreate([{state: 'in_cart', name: 'A'}, { state: 'available', name: 'B'}]).success(function() {
+            done()
+          }.bind(this))
+        }.bind(this))
+      })
+
+      it('correctly restores enum values', function(done) {
+        this.Item.find({ where: { state: 'available' }}).success(function(item) {
+          expect(item.name).toEqual('B')
+          done()
+        }.bind(this))
+      })
+    })
+
+  }) // - bulkCreate
+
+  describe('update', function() {
+
+    it('updates only values that match filter', function(done) {
+      var self = this
+        , data = [{ username: 'Peter', secretValue: '42' },
+                  { username: 'Paul',  secretValue: '42' },
+                  { username: 'Bob',   secretValue: '43' }]
+
+      this.User.bulkCreate(data).success(function() {
+
+        self.User.update({username: 'Bill'}, {secretValue: '42'})
+          .success(function() {
+            self.User.findAll({order: 'id'}).success(function(users) {
+              expect(users.length).toEqual(3)
+
+              users.forEach(function (user) {
+                if (user.secretValue == '42') {
+                  expect(user.username).toEqual("Bill")
+                } else {
+                  expect(user.username).toEqual("Bob")
+                }
+              })
+
+              done()
+            })
+          })
+      })
+    })
+
+    it('sets updatedAt to the current timestamp', function(done) {
+      var self = this
+        , data = [{ username: 'Peter', secretValue: '42' },
+                  { username: 'Paul',  secretValue: '42' },
+                  { username: 'Bob',   secretValue: '43' }]
+
+      this.User.bulkCreate(data).success(function() {
+
+        self.User.update({username: 'Bill'}, {secretValue: '42'})
+          .success(function() {
+            self.User.findAll({order: 'id'}).success(function(users) {
+              expect(users.length).toEqual(3)
+
+              expect(users[0].username).toEqual("Bill")
+              expect(users[1].username).toEqual("Bill")
+              expect(users[2].username).toEqual("Bob")
+
+              expect(parseInt(+users[0].updatedAt/5000)).toEqual(parseInt(+new Date()/5000))
+              expect(parseInt(+users[1].updatedAt/5000)).toEqual(parseInt(+new Date()/5000))
+
+              done()
+            })
+          })
+      })
+    })
+
+  }) // - update
+
+  describe('destroy', function() {
+
+    it('deletes values that match filter', function(done) {
+      var self = this
+        , data = [{ username: 'Peter', secretValue: '42' },
+                  { username: 'Paul',  secretValue: '42' },
+                  { username: 'Bob',   secretValue: '43' }]
+
+      this.User.bulkCreate(data).success(function() {
+
+        self.User.destroy({secretValue: '42'})
+          .success(function() {
+            self.User.findAll({order: 'id'}).success(function(users) {
+              expect(users.length).toEqual(1)
+
+              expect(users[0].username).toEqual("Bob")
+
+              done()
+            })
+          })
+      })
+    })
+
+    it('sets deletedAt to the current timestamp if paranoid is true', function(done) {
+
+      var self = this
+        , User = this.sequelize.define('ParanoidUser', {
+            username:     Sequelize.STRING,
+            secretValue:  Sequelize.STRING,
+            data:         Sequelize.STRING
+          }, {
+            paranoid: true
+          })
+        , data = [{ username: 'Peter', secretValue: '42' },
+                  { username: 'Paul',  secretValue: '42' },
+                  { username: 'Bob',   secretValue: '43' }]
+
+      User.sync({ force: true }).success(function() {
+
+        User.bulkCreate(data).success(function() {
+
+          User.destroy({secretValue: '42'})
+            .success(function() {
+              User.findAll({order: 'id'}).success(function(users) {
+                expect(users.length).toEqual(3)
+
+                expect(users[0].username).toEqual("Peter")
+                expect(users[1].username).toEqual("Paul")
+                expect(users[2].username).toEqual("Bob")
+
+                expect(parseInt(+users[0].deletedAt/5000)).toEqual(parseInt(+new Date()/5000))
+                expect(parseInt(+users[1].deletedAt/5000)).toEqual(parseInt(+new Date()/5000))
+
+                done()
+              })
+            })
+        })
+
+      })
+
+    })
+
+  }) // - destroy
+
   describe('find', function find() {
     before(function(done) {
       this.User.create({