Fix validator so it loops on rawAttributes and not dataValues (then we dont need…

… to have the value defined to validate)

lib/dao-validator.js

@@ -70,9 +70,8 @@ var validateAttributes = function() {
   var self   = this
   var self   = this
     , errors = {}
     , errors = {}
 
 
-  // for each field and value
-  Utils._.each(this.model.dataValues, function(value, field) {
-    var rawAttribute   = self.model.rawAttributes[field]
+  Utils._.each(this.model.rawAttributes, function(rawAttribute, field) {
+    var value          = self.model.dataValues[field] || undefined
       , hasAllowedNull = ((rawAttribute === undefined || rawAttribute.allowNull === true) && ((value === null) || (value === undefined)))
       , hasAllowedNull = ((rawAttribute === undefined || rawAttribute.allowNull === true) && ((value === null) || (value === undefined)))
       , isSkipped      = self.options.skip.length > 0 && self.options.skip.indexOf(field) === -1
       , isSkipped      = self.options.skip.length > 0 && self.options.skip.indexOf(field) === -1
 
 

lib/dialects/mysql/query-generator.js

@@ -175,20 +175,33 @@ module.exports = (function() {
     },
     },
 
 
     bulkInsertQuery: function(tableName, attrValueHashes) {
     bulkInsertQuery: function(tableName, attrValueHashes) {
-      var tuples = []
+      var query = "INSERT INTO <%= table %> (<%= attributes %>) VALUES <%= tuples %>;"
+        , tuples = []
+        , allAttributes = []
+
+      Utils._.forEach(attrValueHashes, function(attrValueHash, i) {
+        Utils._.forEach(attrValueHash, function(value, key, hash) {
+          if (allAttributes.indexOf(key) === -1) allAttributes.push(key)
+        })
+      })
 
 
-      Utils._.forEach(attrValueHashes, function(attrValueHash) {
+      Utils._.forEach(attrValueHashes, function(attrValueHash, i) {
         tuples.push("(" +
         tuples.push("(" +
-          Utils._.values(attrValueHash).map(function(v) { return this.escape(v) }.bind(this)).join(",") +
+          allAttributes.map(function (key) {
+            return this.escape(attrValueHash[key])
+          }.bind(this)).join(",") +
         ")")
         ")")
       }.bind(this))
       }.bind(this))
 
 
-      var table      = this.quoteIdentifier(tableName)
-      var attributes = Object.keys(attrValueHashes[0]).map(function(attr){return this.quoteIdentifier(attr)}.bind(this)).join(",")
-
-      var query  = "INSERT INTO " + table + " (" + attributes + ") VALUES " + tuples.join(",") + ";"
+      var replacements  = {
+        table: this.quoteIdentifier(tableName),
+        attributes: allAttributes.map(function(attr){
+                      return this.quoteIdentifier(attr)
+                    }.bind(this)).join(","),
+        tuples: tuples
+      }
 
 
-      return query
+      return Utils._.template(query)(replacements)
     },
     },
 
 
     updateQuery: function(tableName, attrValueHash, where, options) {
     updateQuery: function(tableName, attrValueHash, where, options) {

lib/dialects/postgres/query-generator.js

@@ -293,34 +293,37 @@ module.exports = (function() {
     },
     },
 
 
     bulkInsertQuery: function(tableName, attrValueHashes) {
     bulkInsertQuery: function(tableName, attrValueHashes) {
-      var query     = "INSERT INTO <%= table %> (<%= attributes %>) VALUES <%= tuples %> RETURNING *;"
-        , tuples    = []
-        , serials   = []
+      var query        = "INSERT INTO <%= table %> (<%= attributes %>) VALUES <%= tuples %> RETURNING *;"
+        , tuples       = []
+        , serials      = []
+        , allAttributes = []
 
 
       Utils._.forEach(attrValueHashes, function(attrValueHash, i) {
       Utils._.forEach(attrValueHashes, function(attrValueHash, i) {
-        if (i === 0) {
-          Utils._.forEach(attrValueHash, function(value, key, hash) {
-            if (tables[tableName] && tables[tableName][key]) {
-              if (['bigserial', 'serial'].indexOf(tables[tableName][key]) !== -1) {
-                serials.push(key)
-              }
+        Utils._.forEach(attrValueHash, function(value, key, hash) {
+          if (allAttributes.indexOf(key) === -1) allAttributes.push(key)
+
+          if (tables[tableName] && tables[tableName][key]) {
+            if (['bigserial', 'serial'].indexOf(tables[tableName][key]) !== -1 && serials.indexOf(key) === -1) {
+              serials.push(key)
             }
             }
-          })
-        }
+          }
+        })
+      })
 
 
+      Utils._.forEach(attrValueHashes, function(attrValueHash, i) {
         tuples.push("(" +
         tuples.push("(" +
-          Utils._.map(attrValueHash, function(value, key){
+          allAttributes.map(function (key) {
             if (serials.indexOf(key) !== -1) {
             if (serials.indexOf(key) !== -1) {
-              return value || 'DEFAULT';
+              return attrValueHash[key] || 'DEFAULT';
             }
             }
-            return this.escape(value)
+            return this.escape(attrValueHash[key])
           }.bind(this)).join(",") +
           }.bind(this)).join(",") +
         ")")
         ")")
       }.bind(this))
       }.bind(this))
 
 
       var replacements  = {
       var replacements  = {
         table:      this.quoteIdentifiers(tableName)
         table:      this.quoteIdentifiers(tableName)
-      , attributes: Object.keys(attrValueHashes[0]).map(function(attr){
+      , attributes: allAttributes.map(function(attr){
                       return this.quoteIdentifier(attr)
                       return this.quoteIdentifier(attr)
                     }.bind(this)).join(",")
                     }.bind(this)).join(",")
       , tuples:     tuples.join(",")
       , tuples:     tuples.join(",")

lib/dialects/sqlite/query-generator.js

@@ -175,18 +175,27 @@ module.exports = (function() {
     bulkInsertQuery: function(tableName, attrValueHashes) {
     bulkInsertQuery: function(tableName, attrValueHashes) {
       var query = "INSERT INTO <%= table %> (<%= attributes %>) VALUES <%= tuples %>;"
       var query = "INSERT INTO <%= table %> (<%= attributes %>) VALUES <%= tuples %>;"
         , tuples = []
         , tuples = []
+        , allAttributes = []
 
 
-      Utils._.forEach(attrValueHashes, function(attrValueHash) {
+      Utils._.forEach(attrValueHashes, function(attrValueHash, i) {
+        Utils._.forEach(attrValueHash, function(value, key, hash) {
+          if (allAttributes.indexOf(key) === -1) allAttributes.push(key)
+        })
+      })
+
+      Utils._.forEach(attrValueHashes, function(attrValueHash, i) {
         tuples.push("(" +
         tuples.push("(" +
-          Utils._.values(attrValueHash).map(function(value){
-            return this.escape(value)
+          allAttributes.map(function (key) {
+            return this.escape(attrValueHash[key])
           }.bind(this)).join(",") +
           }.bind(this)).join(",") +
         ")")
         ")")
       }.bind(this))
       }.bind(this))
 
 
       var replacements  = {
       var replacements  = {
         table: this.quoteIdentifier(tableName),
         table: this.quoteIdentifier(tableName),
-        attributes: Object.keys(attrValueHashes[0]).map(function(attr){return this.quoteIdentifier(attr)}.bind(this)).join(","),
+        attributes: allAttributes.map(function(attr){
+                      return this.quoteIdentifier(attr)
+                    }.bind(this)).join(","),
         tuples: tuples
         tuples: tuples
       }
       }
 
 

test/dao-factory/create.test.js

@@ -700,7 +700,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
       })
       })
     })
     })
 
 
-    it.only('properly handles disparate field lists', function(done) {
+    it('properly handles disparate field lists', function(done) {
       var self = this
       var self = this
         , data = [{username: 'Peter', secretValue: '42' },
         , data = [{username: 'Peter', secretValue: '42' },
                   {username: 'Paul'},
                   {username: 'Paul'},