Merge branch 'master' of github.com:sequelize/sequelize

.jshintrc

-/*
-{
-    "globals": {
-        "spyOn": false,
-        "it": false,
-        "console": false,
-        "describe": false,
-        "expect": false,
-        "beforeEach": false,
-        "afterEach": false,
-        "waits": false,
-        "waitsFor": false,
-        "runs": false
-    },
-    "node": true,
-    "camelcase": true,
-    "curly": true,
-    "forin": true,
-    "indent": 2,
-    "unused": true,
-    "asi": true,
-    "evil": false,
-    "laxcomma": true,
-    "es5": true,
-    "quotmark": false,
-    "undef": true,
-    "strict": false
-}
-*/
-
 {
   "bitwise":false,
   "boss":true,

.travis.yml

@@ -21,7 +21,6 @@ env:
 language: node_js
 
 node_js:
-  - "0.8"
   - "0.10"
 
 branches:

Makefile

@@ -16,12 +16,15 @@ test: codeclimate
 else
 test:
 	@if [ "$$GREP" ]; then \
-		make teaser && ./node_modules/mocha/bin/mocha --globals setImmediate,clearImmediate --check-leaks --colors -t 10000 --reporter $(REPORTER) -g "$$GREP" $(TESTS); \
+		make jshint && make teaser && ./node_modules/mocha/bin/mocha --globals setImmediate,clearImmediate --check-leaks --colors -t 10000 --reporter $(REPORTER) -g "$$GREP" $(TESTS); \
 	else \
-		make teaser && ./node_modules/mocha/bin/mocha --globals setImmediate,clearImmediate --check-leaks --colors -t 10000 --reporter $(REPORTER) $(TESTS); \
+		make jshint && make teaser && ./node_modules/mocha/bin/mocha --globals setImmediate,clearImmediate --check-leaks --colors -t 10000 --reporter $(REPORTER) $(TESTS); \
 	fi
 endif
 
+jshint:
+	./node_modules/.bin/jshint lib
+
 cover:
 	rm -rf coverage \
 	make teaser && ./node_modules/.bin/istanbul cover ./node_modules/.bin/_mocha --report lcovonly -- -t 10000 $(TESTS); \

lib/dialects/abstract/query-generator.js

@@ -785,13 +785,18 @@ module.exports = (function() {
               }
             }
           } else {
-            var primaryKeysLeft = association.associationType === 'BelongsTo' ? association.target.primaryKeyAttributes : include.association.source.primaryKeyAttributes
+            var left = association.associationType === 'BelongsTo' ? association.target : include.association.source
+              , primaryKeysLeft = association.associationType === 'BelongsTo' ? left.primaryKeyAttributes : left.primaryKeyAttributes
               , tableLeft = association.associationType === 'BelongsTo' ? as : parentTable
               , attrLeft = primaryKeysLeft[0]
               , tableRight = association.associationType === 'BelongsTo' ? parentTable : as
               , attrRight = association.identifier
               , joinOn;
 
+            if (left.rawAttributes[attrLeft].field) {
+              attrLeft = left.rawAttributes[attrLeft].field;
+            }
+
             // Filter statement
             // Used by both join and subquery where
             joinOn =

lib/dialects/abstract/query.js

@@ -339,90 +339,306 @@ module.exports = (function() {
         }
       ]
   */
+  /*
+   * Assumptions
+   * ID is not necessarily the first field
+   * All fields for a level is grouped in the same set (i.e. Panel.id, Task.id, Panel.title is not possible)
+   * Parent keys will be seen before any include/child keys
+   * Previous set won't necessarily be parent set (one parent could have two children, one child would then be previous set for the other)
+   */
 
-  // includeOptions are 'level'-specific where options is a general directive
-  var i = 0;
-  var groupJoinData = function(data, includeOptions, options) {
-    var results = []
-      , existingResult
-      , calleeData
-      , child
-      , calleeDataIgnore = ['__children']
-      , parseChildren = function(result) {
-        _.each(result.__children, function(children, key) {
-          result[key] = groupJoinData(children, (includeOptions.includeMap && includeOptions.includeMap[key]), options);
-        });
+   /*
+   * Author (MH) comment: This code is an unreadable mess, but its performant.
+   * groupJoinData is a performance critical function so we prioritize perf over readability.
+   */
 
-        delete result.__children;
+  var groupJoinData = function(rows, includeOptions, options) {
+    if (!rows.length) {
+      return [];
     }
-      , primaryKeyAttribute
-      , primaryKeyMap = {};
 
-    // Ignore all include keys on main data
-    if (includeOptions.includeNames) {
-      calleeDataIgnore = calleeDataIgnore.concat(includeOptions.includeNames);
+    var
+      // Generic looping
+      i
+      , length
+      , $i
+      , $length
+      // Row specific looping
+      , rowsI
+      , rowsLength = rows.length
+      , row
+      // Key specific looping
+      , keys
+      , key
+      , keyI
+      , keyLength
+      , prevKey
+      , values
+      , topValues
+      , topExists
+      , previous
+      , checkExisting = options.checkExisting
+      // If we don't have to deduplicate we can pre-allocate the resulting array
+      , results = checkExisting ? [] : new Array(rowsLength)
+      , resultMap = {}
+      , includeMap = {}
+      , itemHash
+      , parentHash
+      , topHash
+      // Result variables for the respective functions
+      , $keyPrefix
+      , $keyPrefixString
+      , $prevKeyPrefixString
+      , $prevKeyPrefix
+      , $lastKeyPrefix
+      , $current
+      , $parent
+      // Map each key to an include option
+      , previousPiece
+      , buildIncludeMap = function (piece) {
+        if ($current.includeMap[piece]) {
+          includeMap[key] = $current = $current.includeMap[piece];
+          if (previousPiece) {
+            previousPiece = previousPiece+'.'+piece;
+          } else {            
+            previousPiece = piece;
+          }
+          includeMap[previousPiece] = $current;
+        }
+      }
+      // Calcuate the last item in the array prefix ('Results' for 'User.Results.id')
+      , lastKeyPrefixMemo = {}
+      , lastKeyPrefix = function (key) {
+        if (!lastKeyPrefixMemo[key]) {
+          var prefix = keyPrefix(key)
+            , length = prefix.length;
+
+          lastKeyPrefixMemo[key] = !length ? '' : prefix[length - 1];
+        }
+        return lastKeyPrefixMemo[key];
       }
-    if (includeOptions.model.primaryKeyAttributes.length === 1) {
-      primaryKeyAttribute = includeOptions.model.primaryKeyAttribute;
+      // Calculate the string prefix of a key ('User.Results' for 'User.Results.id')
+      , keyPrefixStringMemo = {}
+      , keyPrefixString = function (key, memo) {
+        if (!memo[key]) {
+          memo[key] = key.substr(0, key.lastIndexOf('.'));
         }
+        return memo[key];
+      }
+      // Removes the prefix from a key ('id' for 'User.Results.id')
+      , removeKeyPrefixMemo = {}
+      , removeKeyPrefix = function (key) {
+        if (!removeKeyPrefixMemo[key]) {
+          var index = key.lastIndexOf('.');
+          removeKeyPrefixMemo[key] = key.substr(index === -1 ? 0 : index + 1);
+        }
+        return removeKeyPrefixMemo[key];
+      }
+      // Calculates the array prefix of a key (['User', 'Results'] for 'User.Results.id')
+      , keyPrefixMemo = {}
+      , keyPrefix = function (key) {
+        // We use a double memo and keyPrefixString so that different keys with the same prefix will receive the same array instead of differnet arrays with equal values
+        if (!keyPrefixMemo[key]) {
+          var prefixString = keyPrefixString(key, keyPrefixStringMemo);
+          if (!keyPrefixMemo[prefixString]) {
+            keyPrefixMemo[prefixString] = prefixString ? prefixString.split(".") : [];
+          }
+          keyPrefixMemo[key] = keyPrefixMemo[prefixString];
+        }
+        return keyPrefixMemo[key];
+      }
+      , primaryKeyAttributes
+      , prefix;
 
-    data.forEach(function parseRow(row) {
-      row = Dot.transform(row);
-      calleeData = row;
+    for (rowsI = 0; rowsI < rowsLength; rowsI++) {
+      row = rows[rowsI];
 
-      // If there are :M associations included we need to see if the main result of the row has already been identified
-      if (options.checkExisting) {
-        if (primaryKeyAttribute) {
-          // If we can, detect equality on the singular primary key
-          existingResult = primaryKeyMap[calleeData[primaryKeyAttribute]];
+      // Keys are the same for all rows, so only need to compute them on the first row
+      if (rowsI === 0) {
+        keys = Object.keys(row);
+        keyLength = keys.length;
+      }
+
+      if (checkExisting) {
+        topExists = false;
+
+        // Compute top level hash key (this is usually just the primary key values)
+        $length = includeOptions.model.primaryKeyAttributes.length;
+        if ($length === 1) {
+          topHash = row[includeOptions.model.primaryKeyAttributes[0]];
         } else {
-          // If we can't identify on a singular primary key, do a full row equality check
-          existingResult = _.find(results, function(result) {
-            return Utils._.isEqual(_.omit(result, calleeDataIgnore), calleeData);
-          });
+          topHash = '';
+          for ($i = 0; $i < $length; $i++) {
+            topHash += row[includeOptions.model.primaryKeyAttributes[$i]];
+          }
+        }
+      }
+
+      topValues = values = {};
+      $prevKeyPrefix = undefined;
+      for (keyI = 0; keyI < keyLength; keyI++) {
+        key = keys[keyI];
+
+        // The string prefix isn't actualy needed
+        // We use it so keyPrefix for different keys will resolve to the same array if they have the same prefix
+        // TODO: Find a better way?
+        $keyPrefixString = keyPrefixString(key, keyPrefixStringMemo);
+        $keyPrefix = keyPrefix(key);
+
+        // On the first row we compute the includeMap
+        if (rowsI === 0 && includeMap[key] === undefined) {
+          if (!$keyPrefix.length) {
+            includeMap[key] = includeMap[''] = includeOptions;
+          } else {
+            $current = includeOptions;
+            previousPiece = undefined;
+            $keyPrefix.forEach(buildIncludeMap);
+          }
         }
+
+        // End of key set
+        if ($prevKeyPrefix !== undefined && $prevKeyPrefix !== $keyPrefix) {
+          if (checkExisting) {
+            // Compute hash key for this set instance
+            // TODO: Optimize
+            length = $prevKeyPrefix.length;
+            $parent = null;
+            parentHash = null;
+
+            if (length) {
+              for (i = 0; i < length; i++) {
+                prefix = $parent ? $parent+'.'+$prevKeyPrefix[i] : $prevKeyPrefix[i];
+                primaryKeyAttributes = includeMap[prefix].model.primaryKeyAttributes;
+                $length = primaryKeyAttributes.length;
+                if ($length === 1) {
+                  itemHash = prefix+row[prefix+'.'+primaryKeyAttributes[0]];
                 } else {
-        existingResult = null;
+                  itemHash = prefix;
+                  for ($i = 0; $i < $length; $i++) {
+                    itemHash += row[prefix+'.'+primaryKeyAttributes[$i]];
+                  }
+                }
+                if (!parentHash) {
+                  parentHash = topHash;
                 }
 
-      if (!existingResult) {
-        results.push(existingResult = calleeData);
-        if (options.checkExisting && primaryKeyAttribute) {
-          primaryKeyMap[existingResult[primaryKeyAttribute]] = existingResult;
+                itemHash = parentHash + itemHash;
+                $parent = prefix;
+                if (i < length - 1) {
+                  parentHash = itemHash;
+                }
               }
+            } else {
+              itemHash = topHash;
             }
 
-      for (var attrName in row) {
-        if (row.hasOwnProperty(attrName)) {
-          // Child if object, and is an child include
-          child = Object(row[attrName]) === row[attrName] && includeOptions.includeMap && includeOptions.includeMap[attrName];
+            if (itemHash === topHash) {
+              if (!resultMap[itemHash]) {
+                resultMap[itemHash] = values;
+              } else {
+                topExists = true;
+              }
+            } else {
+              if (!resultMap[itemHash]) {
+                $parent = resultMap[parentHash];
+                $lastKeyPrefix = lastKeyPrefix(prevKey);
+                //console.log($parent, prevKey, $lastKeyPrefix);
+                if (includeMap[prevKey].association.isSingleAssociation) {
+                  $parent[$lastKeyPrefix] = resultMap[itemHash] = values;
+                } else {
+                  if (!$parent[$lastKeyPrefix]) {
+                    $parent[$lastKeyPrefix] = [];
+                  }
+                  $parent[$lastKeyPrefix].push(resultMap[itemHash] = values);
+                }
+              }
+            }
 
-          if (child) {
-            // Make sure nested object is available
-            if (!existingResult.__children) {
-              existingResult.__children = {};
+            // Reset values
+            values = {};
+          } else {
+            // If checkExisting is false it's because there's only 1:1 associations in this query
+            // However we still need to map onto the appropriate parent
+            // For 1:1 we map forward, initializing the value object on the parent to be filled in the next iterations of the loop
+            $current = topValues;
+            length = $keyPrefix.length;
+            if (length) {
+              for (i = 0; i < length; i++) {
+                if (i === length -1) {
+                  values = $current[$keyPrefix[i]] = {};
+                }
+                $current = $current[$keyPrefix[i]];
+              }
+            }
           }
-            if (!existingResult.__children[attrName]) {
-              existingResult.__children[attrName] = [];
         }
 
-            existingResult.__children[attrName].push(row[attrName]);
+        // End of iteration, set value and set prev values (for next iteration)
+        values[removeKeyPrefix(key)] = row[key];
+        prevKey = key;
+        $prevKeyPrefix = $keyPrefix;
+        $prevKeyPrefixString = $keyPrefixString;
+      }
 
-            // Remove from main
-            delete existingResult[attrName];
+      if (checkExisting) {
+        length = $prevKeyPrefix.length;
+        $parent = null;
+        parentHash = null;
+
+        if (length) {
+          for (i = 0; i < length; i++) {
+            prefix = $parent ? $parent+'.'+$prevKeyPrefix[i] : $prevKeyPrefix[i];
+            primaryKeyAttributes = includeMap[prefix].model.primaryKeyAttributes;
+            $length = primaryKeyAttributes.length;
+            if ($length === 1) {
+              itemHash = prefix+row[prefix+'.'+primaryKeyAttributes[0]];
+            } else {
+              itemHash = prefix;
+              for ($i = 0; $i < $length; $i++) {
+                itemHash += row[prefix+'.'+primaryKeyAttributes[$i]];
               }
             }
+            if (!parentHash) {
+              parentHash = topHash;
             }
 
-      // parseChildren in same loop if no duplicate values are possible
-      if (!options.checkExisting) {
-        parseChildren(existingResult);
+            itemHash = parentHash + itemHash;
+            $parent = prefix;
+            if (i < length - 1) {
+              parentHash = itemHash;
+            }
+          }
+        } else {
+          itemHash = topHash;
         }
-    });
 
-    // parseChildren after row parsing if duplicate values are possible
-    if (options.checkExisting) {
-      results.forEach(parseChildren);
+        if (itemHash === topHash) {
+          if (!resultMap[itemHash]) {
+            resultMap[itemHash] = values;
+          } else {
+            topExists = true;
+          }
+        } else {
+          if (!resultMap[itemHash]) {
+            $parent = resultMap[parentHash];
+            $lastKeyPrefix = lastKeyPrefix(prevKey);
+            //console.log($parent, prevKey, $lastKeyPrefix);
+            if (includeMap[prevKey].association.isSingleAssociation) {
+              $parent[$lastKeyPrefix] = resultMap[itemHash] = values;
+            } else {
+              if (!$parent[$lastKeyPrefix]) {
+                $parent[$lastKeyPrefix] = [];
+              }
+              $parent[$lastKeyPrefix].push(resultMap[itemHash] = values);
+            }
+          }
+        }
+        if (!topExists) {
+          results.push(topValues);
+        }
+      } else {
+        results[rowsI] = topValues;
+      }
     }
 
     return results;

lib/instance.js

@@ -363,7 +363,7 @@ module.exports = (function() {
       , accessor = Utils._.camelize(key)
       , childOptions
       , primaryKeyAttribute  = include.model.primaryKeyAttribute
-      , isEmpty = value[0] && value[0][primaryKeyAttribute] === null;
+      , isEmpty;
 
     if (!isEmpty) {
       childOptions = {
@@ -382,9 +382,15 @@ module.exports = (function() {
       accessor = accessor.slice(0, 1).toLowerCase() + accessor.slice(1);
 
       if (association.isSingleAssociation) {
+        if (Array.isArray(value)) {
+          value = value[0];
+        }
+
+        isEmpty = value && value[primaryKeyAttribute] === null;
         accessor = Utils.singularize(accessor, self.Model.options.language);
-        self[accessor] = self.dataValues[accessor] = isEmpty ? null : include.model.build(value[0], childOptions);
+        self[accessor] = self.dataValues[accessor] = isEmpty ? null : include.model.build(value, childOptions);
       } else {
+        isEmpty = value[0] && value[0][primaryKeyAttribute] === null;
         self[accessor] = self.dataValues[accessor] = isEmpty ? [] : include.model.bulkBuild(value, childOptions);
       }
     }
@@ -506,6 +512,16 @@ module.exports = (function() {
       } else {
         var identifier = self.primaryKeyValues;
 
+        if (identifier) {
+          for (var attrName in identifier) {
+            // Field name mapping
+            if (self.Model.rawAttributes[attrName].field) {
+              identifier[self.Model.rawAttributes[attrName].field] = identifier[attrName];
+              delete identifier[attrName];
+            }
+          }
+        }
+
         if (identifier === null && self.__options.whereCollection !== null) {
           identifier = self.__options.whereCollection;
         }

lib/model.js

@@ -1230,8 +1230,17 @@ module.exports = (function() {
             }
           });
 
+          // Map attributes for serial identification
+          var attributes = {};
+          for (var attr in self.rawAttributes) {
+            attributes[attr] = self.rawAttributes[attr];
+            if (self.rawAttributes[attr].field) {
+              attributes[self.rawAttributes[attr].field] = self.rawAttributes[attr];
+            }
+          }
+
           // Insert all records at once
-          return self.QueryInterface.bulkInsert(self.getTableName(), records, options, self).then(runAfterCreate);
+          return self.QueryInterface.bulkInsert(self.getTableName(), records, options, attributes).then(runAfterCreate);
         } else {
           // Records were already saved while running create / update hooks
           return runAfterCreate();
@@ -1461,6 +1470,9 @@ module.exports = (function() {
   var mapFieldNames = function(options, Model) {
     if (options.attributes) {
       options.attributes = options.attributes.map(function(attr) {
+        // Object lookups will force any variable to strings, we don't want that for special objects etc
+        if (typeof attr !== "string") return attr;
+        // Map attributes to aliased syntax attributes
         if (Model.rawAttributes[attr] && Model.rawAttributes[attr].field) {
           return [Model.rawAttributes[attr].field, attr];
         }
@@ -1470,12 +1482,14 @@ module.exports = (function() {
 
     if (options.where) {
       for (var attr in options.where) {
+        if (typeof attr === "string") {
           if (Model.rawAttributes[attr] && Model.rawAttributes[attr].field) {
             options.where[Model.rawAttributes[attr].field] = options.where[attr];
             delete options.where[attr];
           }
         }
       }
+    }
     return options;
   };
 

lib/query-interface.js

@@ -423,8 +423,8 @@ module.exports = (function() {
     });
   };
 
-  QueryInterface.prototype.bulkInsert = function(tableName, records, options, Model) {
-    var sql = this.QueryGenerator.bulkInsertQuery(tableName, records, options, Model.rawAttributes);
+  QueryInterface.prototype.bulkInsert = function(tableName, records, options, attributes) {
+    var sql = this.QueryGenerator.bulkInsertQuery(tableName, records, options, attributes);
     return this.sequelize.query(sql, null, options);
   };
 

package.json

@@ -71,7 +71,8 @@
     "async": "~0.2.10",
     "coffee-script": "~1.7.1",
     "markdox": "0.1.4",
-    "sinon-chai": "~2.5.0"
+    "sinon-chai": "~2.5.0",
+    "jshint": ">=2.4.2"
   },
   "keywords": [
     "mysql",

test/model/attributes.test.js

@@ -7,10 +7,10 @@ var chai      = require('chai')
   , Support   = require(__dirname + '/../support')
   , DataTypes = require(__dirname + "/../../lib/data-types")
   , dialect   = Support.getTestDialect()
-  , datetime  = require('chai-datetime')
+  , datetime  = require('chai-datetime');
 
-chai.use(datetime)
-chai.config.includeStack = true
+chai.use(datetime);
+chai.config.includeStack = true;
 
 describe(Support.getTestDialectTeaser("Model"), function () {
   describe('attributes', function () {
@@ -19,6 +19,13 @@ describe(Support.getTestDialectTeaser("Model"), function () {
         var queryInterface = this.sequelize.getQueryInterface();
 
         this.User = this.sequelize.define('user', {
+          id: {
+            type: DataTypes.INTEGER,
+            allowNull: false,
+            primaryKey: true,
+            autoIncrement: true,
+            field: 'userId'
+          },
           name: {
             type: DataTypes.STRING,
             field: 'full_name'
@@ -54,7 +61,7 @@ describe(Support.getTestDialectTeaser("Model"), function () {
 
         return Promise.all([
           queryInterface.createTable('users', {
-            id: {
+            userId: {
               type: DataTypes.INTEGER,
               allowNull: false,
               primaryKey: true,
@@ -78,7 +85,7 @@ describe(Support.getTestDialectTeaser("Model"), function () {
               type: DataTypes.STRING
             }
           })
-        ])
+        ]);
       });
 
       it('should create, fetch and update with alternative field names from a simple model', function () {
@@ -101,7 +108,7 @@ describe(Support.getTestDialectTeaser("Model"), function () {
           });
         }).then(function (user) {
           expect(user.get('name')).to.equal('Barfoo');
-        })
+        });
       });
 
       it('should work with attributes and where on includes', function () {
@@ -139,8 +146,8 @@ describe(Support.getTestDialectTeaser("Model"), function () {
             }
           });
         }).then(function (user) {
-          expect(user).to.be.ok
-        })
+          expect(user).to.be.ok;
+        });
       });
 
       it('should work with bulkCreate and findAll', function () {
@@ -155,17 +162,17 @@ describe(Support.getTestDialectTeaser("Model"), function () {
           return self.User.findAll();
         }).then(function (users) {
           users.forEach(function (user) {
-            expect(['Abc', 'Bcd', 'Cde'].indexOf(user.get('name')) !== -1).to.be.true
+            expect(['Abc', 'Bcd', 'Cde'].indexOf(user.get('name')) !== -1).to.be.true;
+          });
         });
       });
     });
-    })
 
     describe('types', function () {
       describe('VIRTUAL', function () {
         it('should be ignored in create, updateAttributes and find');
         it('should be ignored in bulkCreate and findAll');
-      })
-    })
-  })
-})
\ No newline at end of file
+      });
+    });
+  });
+});
\ No newline at end of file