Merge pull request #569 from optilude/master

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

Merge pull request #569 from optilude/master
Support for bulk insert, update and delete operations at the DAOFactory level
Jan Aagaard Meier
Commit fedb9cde authored May 09, 2013 by Jan Aagaard Meier
Showing with 671 additions and 35 deletions
changelog.md
lib/dao-factory.js
lib/dialects/mysql/query-generator.js
lib/dialects/postgres/query-generator.js
lib/dialects/postgres/query.js
lib/dialects/query-generator.js
lib/dialects/sqlite/query-generator.js
lib/query-interface.js
spec-jasmine/mysql/query-generator.spec.js
spec-jasmine/postgres/query-generator.spec.js
spec-jasmine/sqlite/query-generator.spec.js
spec/dao-factory.spec.js
--- a/changelog.md
+++ b/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

--- a/lib/dao-factory.js
+++ b/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() {

--- a/lib/dialects/mysql/query-generator.js
+++ b/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)

--- a/lib/dialects/postgres/query-generator.js
+++ b/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 = []
+        , returning = removeSerialsFromHash(tableName, attrValueHash)
-      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
-          }
-        }
-      });
      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)
 })()
--- a/lib/dialects/postgres/query.js
+++ b/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(this.callee !== null) { // may happen for bulk inserts
-        if (rows[0].hasOwnProperty(key)) {
+        for (var key in rows[0]) {
-          var record = rows[0][key]
+          if (rows[0].hasOwnProperty(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) {
+            var record = rows[0][key]
-            record = this.callee.daoFactory.daoFactoryManager.sequelize.queryInterface.QueryGenerator.toHstore(record)
+            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(this.callee !== null) { // may happen for bulk updates
-        if (rows[0].hasOwnProperty(key)) {
+        for (var key in rows[0]) {
-          var record = rows[0][key]
+          if (rows[0].hasOwnProperty(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) {
+            var record = rows[0][key]
-            record = this.callee.daoFactory.daoFactoryManager.sequelize.queryInterface.QueryGenerator.toHstore(record)
+            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
        }
      }

--- a/lib/dialects/query-generator.js
+++ b/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

--- a/lib/dialects/sqlite/query-generator.js
+++ b/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),
+        where: MySqlQueryGenerator.getWhereConditions(where)
-        limit: Utils.escape(options.limit)
      }
      return Utils._.template(query)(replacements)

--- a/lib/query-interface.js
+++ b/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 || {}

--- a/spec-jasmine/mysql/query-generator.spec.js
+++ b/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'"
      }
    ],

--- a/spec-jasmine/postgres/query-generator.spec.js
+++ b/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')"
      }
    ],

--- a/spec-jasmine/sqlite/query-generator.spec.js
+++ b/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'"
+      }
    ]
  };

--- a/spec/dao-factory.spec.js
+++ b/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({