Merge branch 'ErikvdVen-master'

changelog.md

@@ -2,6 +2,7 @@
 - [BUG] Fixed issue with paranoid deletes and `deletedAt` with a custom field.
 - [BUG] No longer crahes on `where: []`
 - [FEATURE] Validations are now enabled by default for upsert.
+- [FEATURE] Preliminary support for `include.through.where`
 
 # 2.0.0-rc7
 - [FEATURE] Throw an error if no where clause is given to `Model.destroy()`.

lib/dialects/abstract/query-generator.js

@@ -974,7 +974,9 @@ module.exports = (function() {
 
               , sourceJoinOn
               , targetJoinOn
-              , targetWhere;
+              , targetWhere
+
+              , throughWhere;
 
             if (options.includeIgnoreAttributes !== false) {
               // Through includes are always hasMany, so we need to add the attributes to the mainAttributes no matter what (Real join will never be executed in subquery)
@@ -991,12 +993,21 @@ module.exports = (function() {
             targetJoinOn = self.quoteIdentifier(tableTarget) + '.' + self.quoteIdentifier(attrTarget) + ' = ';
             targetJoinOn += self.quoteIdentifier(throughAs) + '.' + self.quoteIdentifier(identTarget);
 
+            if (include.through.where) {
+              throughWhere = self.getWhereConditions(include.through.where, self.sequelize.literal(self.quoteIdentifier(throughAs)), include.through.model);
+            }
+
             if (self._dialect.supports.joinTableDependent) {
               // Generate a wrapped join so that the through table join can be dependent on the target join
               joinQueryItem += joinType + '(';
               joinQueryItem += self.quoteTable(throughTable, throughAs);
               joinQueryItem += joinType + self.quoteTable(table, as) + ' ON ';
               joinQueryItem += targetJoinOn;
+
+              if (throughWhere) {
+                joinQueryItem += ' AND ' + throughWhere;
+              }
+
               joinQueryItem += ') ON '+sourceJoinOn;
             } else {
               // Generate join SQL for left side of through
@@ -1006,11 +1017,18 @@ module.exports = (function() {
               // Generate join SQL for right side of through
               joinQueryItem += joinType + self.quoteTable(table, as) + ' ON ';
               joinQueryItem += targetJoinOn;
+
+              if (throughWhere) {
+                joinQueryItem += ' AND ' + throughWhere;
+              }
+
             }
 
-            if (include.where) {
-              targetWhere = self.getWhereConditions(include.where, self.sequelize.literal(self.quoteIdentifier(as)), include.model, whereOptions);
-              joinQueryItem += ' AND ' + targetWhere;
+            if (include.where || include.through.where) {
+              if (include.where) {
+                targetWhere = self.getWhereConditions(include.where, self.sequelize.literal(self.quoteIdentifier(as)), include.model, whereOptions);
+                joinQueryItem += ' AND ' + targetWhere;
+              }
               if (subQuery && include.required) {
                 if (!options.where) options.where = {};
                 (function (include) {
@@ -1050,12 +1068,13 @@ module.exports = (function() {
                         include: topInclude.include,
                         _pseudo: true
                       }],
-                      where: {
-                        $join: self.sequelize.asIs([
+                      where: self.sequelize.and(
+                        self.sequelize.asIs([
                           self.quoteTable(topParent.model.name) + '.' + self.quoteIdentifier(topParent.model.primaryKeyAttributes[0]),
                           self.quoteIdentifier(topInclude.through.model.name) + '.' + self.quoteIdentifier(topInclude.association.identifierField)
-                        ].join(" = "))
-                      },
+                        ].join(" = ")),
+                        topInclude.through.where
+                      ),
                       limit: 1,
                       includeIgnoreAttributes: false
                     }, topInclude.through.model);

test/include/findAll.test.js

@@ -1750,6 +1750,58 @@ describe(Support.getTestDialectTeaser('Include'), function() {
       });
     });
 
+
+    it('should be possible to select on columns inside a through table', function(done) {
+      var self = this;
+      this.fixtureA(function() {
+        self.models.Product.findAll({
+          attributes: ['title'],
+          include: [
+            {
+              model: self.models.Tag,
+              through: {
+                where: {
+                  ProductId: 3
+                }
+              },
+              required: true
+            }
+          ]
+        }).done(function(err, products) {
+          expect(err).not.to.be.ok;
+          expect(products).have.length(1);
+
+          done();
+        });
+      });
+    });
+
+    it('should be possible to select on columns inside a through table and a limit', function(done) {
+      var self = this;
+      this.fixtureA(function() {
+        self.models.Product.findAll({
+          attributes: ['title'],
+          include: [
+            {
+              model: self.models.Tag,
+              through: {
+                where: {
+                  ProductId: 3
+                }
+              },
+              required: true
+            }
+          ],
+          limit: 5
+        }).done(function(err, products) {
+          expect(err).not.to.be.ok;
+          expect(products).have.length(1);
+
+          done();
+        });
+      });
+    });
+
     // Test case by @eshell
     it('should be possible not to include the main id in the attributes', function(done) {
       var Member = this.sequelize.define('Member', {
@@ -1999,18 +2051,18 @@ describe(Support.getTestDialectTeaser('Include'), function() {
         });
       });
     });
-    
+
     it('should work on a nested set of required 1:1 relations', function () {
       var Person = this.sequelize.define("Person", {
-        name: { 
+        name: {
           type          : Sequelize.STRING,
           allowNull     : false
         }
       });
 
       var UserPerson = this.sequelize.define("UserPerson", {
-        PersonId: { 
-          type          : Sequelize.INTEGER, 
+        PersonId: {
+          type          : Sequelize.INTEGER,
           primaryKey    : true
         },
 
@@ -2020,8 +2072,8 @@ describe(Support.getTestDialectTeaser('Include'), function() {
       });
 
       var User = this.sequelize.define("User", {
-        UserPersonId: { 
-          type          : Sequelize.INTEGER, 
+        UserPersonId: {
+          type          : Sequelize.INTEGER,
           primaryKey    : true
         },
 
@@ -2032,20 +2084,20 @@ describe(Support.getTestDialectTeaser('Include'), function() {
         }
       });
 
-      UserPerson.belongsTo(Person, { 
-        foreignKey: { 
+      UserPerson.belongsTo(Person, {
+        foreignKey: {
           allowNull: false
         },
         onDelete: 'CASCADE'
       });
-      Person.hasOne(UserPerson, { 
-        foreignKey: { 
+      Person.hasOne(UserPerson, {
+        foreignKey: {
           allowNull: false
         },
         onDelete: 'CASCADE'
       });
-      
-      User.belongsTo(UserPerson, { 
+
+      User.belongsTo(UserPerson, {
         foreignKey: {
           name: 'UserPersonId',
           allowNull: false
@@ -2053,7 +2105,7 @@ describe(Support.getTestDialectTeaser('Include'), function() {
         onDelete: 'CASCADE'
       });
       UserPerson.hasOne(User, {
-        foreignKey: { 
+        foreignKey: {
           name: 'UserPersonId',
           allowNull: false
         },
@@ -2063,12 +2115,12 @@ describe(Support.getTestDialectTeaser('Include'), function() {
       return this.sequelize.sync({force: true}).then(function () {
         return Person.findAll({
           offset        : 0,
-          limit         : 20, 
+          limit         : 20,
           attributes    : ['id', 'name'],
           include       : [{
-            model         : UserPerson, 
-            required      : true, 
-            attributes    : ['rank'], 
+            model         : UserPerson,
+            required      : true,
+            attributes    : ['rank'],
             include       : [{
               model         : User,
               required      : true,