Merge remote-tracking branch 'sdepold/master' into performancecherry

.travis.yml

@@ -21,4 +21,3 @@ node_js:
   - 0.6
   - 0.8
   - 0.9
-

lib/associations/has-many.js

@@ -6,6 +6,7 @@ var HasManySingleLinked = require("./has-many-single-linked")
 
 module.exports = (function() {
   var HasMany = function(srcDAO, targetDAO, options) {
+    this.associationType = 'HasMany'
     this.source = srcDAO
     this.target = targetDAO
     this.options = options
@@ -53,6 +54,7 @@ module.exports = (function() {
       combinedTableAttributes[this.foreignIdentifier] = {type:DataTypes.INTEGER, primaryKey: true}
 
       this.connectorDAO = this.source.daoFactoryManager.sequelize.define(this.combinedName, combinedTableAttributes, this.options)
+
       if(!this.isSelfAssociation) {
         this.target.associations[this.associationAccessor].connectorDAO = this.connectorDAO
       }

lib/dialects/mysql/query-generator.js

@@ -115,9 +115,10 @@ module.exports = (function() {
 
     selectQuery: function(tableName, options) {
       var query = "SELECT <%= attributes %> FROM <%= table %>"
+        , table = null
 
       options            = options || {}
-      options.table = Array.isArray(tableName) ? tableName.map(function(tbl){ return Utils.addTicks(tbl) }).join(", ") : Utils.addTicks(tableName)
+      options.table      = table = Array.isArray(tableName) ? tableName.map(function(tbl){ return Utils.addTicks(tbl) }).join(", ") : Utils.addTicks(tableName)
       options.attributes = options.attributes && options.attributes.map(function(attr){
         if(Array.isArray(attr) && attr.length == 2) {
           return [attr[0], Utils.addTicks(attr[1])].join(' as ')
@@ -128,25 +129,47 @@ module.exports = (function() {
       options.attributes = options.attributes || '*'
 
       if (options.include) {
-        var tableNames    = [options.table]
-          , optAttributes = [options.table + '.*']
+        var optAttributes = [options.table + '.*']
 
         for (var daoName in options.include) {
           if (options.include.hasOwnProperty(daoName)) {
             var dao         = options.include[daoName]
+              , daoFactory  = dao.daoFactoryManager.getDAO(tableName, {
+                  attribute: 'tableName'
+                })
               , _tableName  = Utils.addTicks(dao.tableName)
+              , association = dao.getAssociation(daoFactory)
+
+            if (association.connectorDAO) {
+              var foreignIdentifier = Utils._.keys(association.connectorDAO.rawAttributes).filter(function(attrName) {
+                return (!!attrName.match(/.+Id$/) || !!attrName.match(/.+_id$/)) && (attrName !== association.identifier)
+              })[0]
+
+              query += ' LEFT OUTER JOIN ' + Utils.addTicks(association.connectorDAO.tableName) + ' ON '
+              query += Utils.addTicks(association.connectorDAO.tableName) + '.'
+              query += Utils.addTicks(foreignIdentifier) + '='
+              query += Utils.addTicks(table) + '.' + Utils.addTicks('id')
+
+              query += ' LEFT OUTER JOIN ' + Utils.addTicks(dao.tableName) + ' ON '
+              query += Utils.addTicks(dao.tableName) + '.'
+              query += Utils.addTicks('id') + '='
+              query += Utils.addTicks(association.connectorDAO.tableName) + '.' + Utils.addTicks(association.identifier)
+            } else {
+              query += ' LEFT OUTER JOIN ' + Utils.addTicks(dao.tableName) + ' ON '
+              query += Utils.addTicks(association.associationType === 'BelongsTo' ? dao.tableName : tableName) + '.'
+              query += Utils.addTicks(association.identifier) + '='
+              query += Utils.addTicks(table) + '.' + Utils.addTicks('id')
+            }
 
-            tableNames.push(_tableName)
             optAttributes = optAttributes.concat(
               Utils._.keys(dao.attributes).map(function(attr) {
-                var identifer = [_tableName, Utils.addTicks(attr)]
-                return identifer.join('.') + ' AS ' + Utils.addTicks(identifer.join('.'))
+                var identifier = [_tableName, Utils.addTicks(attr)]
+                return identifier.join('.') + ' AS ' + Utils.addTicks(identifier.join('.'))
               })
             )
           }
         }
 
-        options.table      = tableNames.join(', ')
         options.attributes = optAttributes.join(', ')
       }
 

lib/dialects/postgres/query-generator.js

@@ -202,8 +202,8 @@ module.exports = (function() {
             tableNames.push(_tableName)
             optAttributes = optAttributes.concat(
               Utils._.keys(dao.attributes).map(function(attr) {
-                var identifer = [_tableName, Utils.addTicks(attr)]
-                return identifer.join('.') + ' AS ' + Utils.addTicks(identifer.join('.'))
+                var identifier = [_tableName, Utils.addTicks(attr)]
+                return identifier.join('.') + ' AS ' + Utils.addTicks(identifier.join('.'))
               })
             )
           }

package.json

 {
   "name": "sequelize",
   "description": "Multi dialect ORM for Node.JS",
-  "version": "1.6.0-alpha-2",
+  "version": "1.6.0-alpha-3",
   "author": "Sascha Depold <sascha@depold.com>",
   "contributors": [
     {

spec/associations/belongs-to.spec.js

@@ -20,20 +20,20 @@ describe("[" + dialect.toUpperCase() + "] BelongsTo", function() {
 
   describe('setAssociation', function() {
     it('clears the association if null is passed', function(done) {
-      var User = this.sequelize.define('User', { username: Sequelize.STRING })
-        , Task = this.sequelize.define('Task', { title: Sequelize.STRING })
+      var User = this.sequelize.define('UserXYZ', { username: Sequelize.STRING })
+        , Task = this.sequelize.define('TaskXYZ', { title: Sequelize.STRING })
 
       Task.belongsTo(User)
 
       this.sequelize.sync({ force: true }).success(function() {
         User.create({ username: 'foo' }).success(function(user) {
           Task.create({ title: 'task' }).success(function(task) {
-            task.setUser(user).success(function() {
-              task.getUser().success(function(user) {
+            task.setUserXYZ(user).success(function() {
+              task.getUserXYZ().success(function(user) {
                 expect(user).not.toEqual(null)
 
-                task.setUser(null).success(function() {
-                  task.getUser().success(function(user) {
+                task.setUserXYZ(null).success(function() {
+                  task.getUserXYZ().success(function(user) {
                     expect(user).toEqual(null)
                     done()
                   })

spec/associations/has-one.spec.js

@@ -6,7 +6,7 @@ if (typeof require === 'function') {
 }
 
 buster.spec.expose()
-buster.testRunner.timeout = 500
+buster.testRunner.timeout = 1500
 
 describe("[" + dialect.toUpperCase() + "] HasOne", function() {
   before(function(done) {
@@ -21,20 +21,20 @@ describe("[" + dialect.toUpperCase() + "] HasOne", function() {
 
   describe('setAssociation', function() {
     it('clears the association if null is passed', function(done) {
-      var User = this.sequelize.define('User', { username: Sequelize.STRING })
-        , Task = this.sequelize.define('Task', { title: Sequelize.STRING })
+      var User = this.sequelize.define('UserXYZ', { username: Sequelize.STRING })
+        , Task = this.sequelize.define('TaskXYZ', { title: Sequelize.STRING })
 
       User.hasOne(Task)
 
       this.sequelize.sync({ force: true }).success(function() {
         User.create({ username: 'foo' }).success(function(user) {
           Task.create({ title: 'task' }).success(function(task) {
-            user.setTask(task).success(function() {
-              user.getTask().success(function(task) {
+            user.setTaskXYZ(task).success(function() {
+              user.getTaskXYZ().success(function(task) {
                 expect(task).not.toEqual(null)
 
-                user.setTask(null).success(function() {
-                  user.getTask().success(function(task) {
+                user.setTaskXYZ(null).success(function() {
+                  user.getTaskXYZ().success(function(task) {
                     expect(task).toEqual(null)
                     done()
                   })

spec/dao-factory.spec.js

@@ -364,13 +364,13 @@ describe("[" + dialect.toUpperCase() + "] DAOFactory", function() {
       })
     })
 
-    it('//returns the selected fields as instance.selectedValues', function(done) {
+    it('returns the selected fields as instance.selectedValues', function(done) {
       this.User.create({
         username: 'JohnXOXOXO'
       }).success(function() {
         this.User.find({
           where: { username: 'JohnXOXOXO' },
-          select: ['username']
+          attributes: ['username']
         }).success(function(user) {
           expect(user.selectedValues).toEqual({ username: 'JohnXOXOXO' })
           done()
@@ -550,7 +550,7 @@ describe("[" + dialect.toUpperCase() + "] DAOFactory", function() {
   }) //- describe: find
 
   describe('findAll', function findAll() {
-    describe('association fetching', function() {
+    describe('include', function() {
       before(function() {
         this.Task = this.sequelize.define('Task', {
           title: Sequelize.STRING
@@ -561,6 +561,34 @@ describe("[" + dialect.toUpperCase() + "] DAOFactory", function() {
         })
       })
 
+      it('fetches data only for the relevant where clause', function(done) {
+        this.User.hasOne(this.Task)
+        this.Task.belongsTo(this.User)
+
+        this.sequelize.sync({ force: true }).success(function() {
+          this.User.create({ name: 'barfooz' }).success(function(user1) {
+            this.User.create({ name: 'barfooz' }).success(function(user2) {
+              this.Task.create({ title: 'task' }).success(function(task) {
+                var where = [Sequelize.Utils.addTicks(this.User.tableName) + ".`id`=?", user1.id]
+
+                if (dialect === 'postgres') {
+                  where = ['"' + this.User.tableName + '"."id"=?', user1.id]
+                }
+
+                this.User.findAll({
+                  where: where,
+                  include: [ 'Task' ]
+                }).success(function(users){
+                  expect(users.length).toEqual(1)
+                  // console.log(users[0])
+                  done()
+                }.bind(this))
+              }.bind(this))
+            }.bind(this))
+          }.bind(this))
+        }.bind(this))
+      })
+
       it('fetches associated objects for 1:1 associations (1st direction)', function(done) {
         this.User.hasOne(this.Task)
         this.Task.belongsTo(this.User)

spec/sequelize.spec.js

@@ -34,26 +34,39 @@ describe("[" + dialect.toUpperCase() + "] Sequelize", function() {
         username: Helpers.Sequelize.STRING
       })
 
-      this.insertQuery = "INSERT INTO " + this.User.tableName + " (username) VALUES ('john')"
+      this.insertQuery = "INSERT INTO " + this.User.tableName + " (username, createdAt, updatedAt) VALUES ('john', '2012-01-01 10:10:10', '2012-01-01 10:10:10')"
 
-      this.User.sync().success(done)
+      this.User.sync().success(done).error(function(err) {
+        console(err)
+        done()
+      })
     })
 
-    it('//executes a query the internal way', function(done) {
-      this.sequelize.query(this.insertQuery, null, { raw: true }).success(function(result) {
+    it('executes a query the internal way', function(done) {
+      this.sequelize.query(this.insertQuery, null, { raw: true }).success(function(result) {
         expect(result).toBeNull()
         done()
       })
+      .error(function(err) {
+        console.log(err)
+        expect(err).not.toBeDefined()
+        done()
+      })
     })
 
-    it('//executes a query if only the sql is passed', function(done) {
+    it('executes a query if only the sql is passed', function(done) {
       this.sequelize.query(this.insertQuery).success(function(result) {
-        expect(result).toBeNull()
+        expect(result).not.toBeDefined()
+        done()
+      })
+      .error(function(err) {
+        console.log(err)
+        expect(err).not.toBeDefined()
         done()
       })
     })
 
-    it('//executes select queries correctly', function(done) {
+    it('executes select queries correctly', function(done) {
       this.sequelize.query(this.insertQuery).success(function() {
         this.sequelize
           .query("select * from " + this.User.tableName)