feat(has-many): integrate groupedLimit into hasMany.get to support limit with include.seperate

lib/associations/has-many.js

@@ -259,7 +259,8 @@ HasMany.prototype.get = function(instances, options) {
   var association = this
     , where = {}
     , Model = association.target
-    , instance;
+    , instance
+    , values;
 
   if (!Array.isArray(instances)) {
     instance = instances;
@@ -273,15 +274,28 @@ HasMany.prototype.get = function(instances, options) {
   }
 
   if (instances) {
-    where[association.foreignKey] = {
-      $in: instances.map(function (instance) {
+    values = instances.map(function (instance) {
       return instance.get(association.source.primaryKeyAttribute, {raw: true});
-      })
+    });
+
+    if (options.limit) {
+      options.groupedLimit = {
+        limit: options.limit,
+        on: association.foreignKey,
+        values: values
+      };
+
+      delete options.limit;
+    } else {
+      where[association.foreignKey] = {
+        $in: values
       };
+    }
   } else {
     where[association.foreignKey] = instance.get(association.source.primaryKeyAttribute, {raw: true});
   }
 
+
   options.where = options.where ?
                   {$and: [where, options.where]} :
                   where;

lib/dialects/abstract/index.js

@@ -11,7 +11,8 @@ AbstractDialect.prototype.supports = {
   'LIMIT ON UPDATE': false,
   'ON DUPLICATE KEY': true,
   'ORDER NULLS': false,
-
+  'UNION': true,
+  'UNION ALL': true,
   /* What is the dialect's keyword for INSERT IGNORE */
   'IGNORE': '',
 
@@ -46,6 +47,7 @@ AbstractDialect.prototype.supports = {
     using: true,
   },
   joinTableDependent: true,
+  groupedLimit: true,
   indexViaAlter: false,
   JSON: false,
   deferrableConstraints: false

lib/dialects/abstract/query-generator.js

@@ -1025,10 +1025,10 @@ var QueryGenerator = {
     mainAttributes = mainAttributes || (options.include ? [mainTableAs + '.*'] : ['*']);
 
     // If subquery, we ad the mainAttributes to the subQuery and set the mainAttributes to select * from subquery
-    if (subQuery) {
+    if (subQuery || options.groupedLimit) {
       // We need primary keys
       subQueryAttributes = mainAttributes;
-      mainAttributes = [mainTableAs + '.*'];
+      mainAttributes = [(mainTableAs || table) + '.*'];
     }
 
     if (options.include) {
@@ -1314,7 +1314,7 @@ var QueryGenerator = {
 
         if (include.include) {
           include.include.filter(function (include) {
-            return !include.seperate;
+            return !include.separate;
           }).forEach(function(childInclude) {
             if (childInclude._pseudo) return;
             var childJoinQueries = generateJoinQueries(childInclude, as);
@@ -1334,7 +1334,7 @@ var QueryGenerator = {
 
       // Loop through includes and generate subqueries
       options.include.filter(function (include) {
-        return !include.seperate;
+        return !include.separate;
       }).forEach(function(include) {
         var joinQueries = generateJoinQueries(include, mainTableAs);
 
@@ -1359,21 +1359,24 @@ var QueryGenerator = {
           mainTableAs = table;
         }
 
-        mainQueryItems.push('SELECT * FROM ('+
+        mainQueryItems.push('SELECT '+mainAttributes.join(', ')+' FROM ('+
           options.groupedLimit.values.map(function (value) {
             var where = _.assign({}, options.where);
             where[options.groupedLimit.on] = value;
 
             return '('+self.selectQuery(
-              options.table,
+              table,
               {
                 attributes: options.attributes,
                 limit: options.groupedLimit.limit,
                 order: options.order,
                 where: where
-              }
+              },
+              model
             ).replace(/;$/, '')+')';
-          }).join(' UNION ALL ')
+          }).join(
+            self._dialect.supports['UNION ALL'] ?' UNION ALL ' : ' UNION '
+          )
         +')');
       } else {
         mainQueryItems.push('SELECT ' + mainAttributes.join(', ') + ' FROM ' + table);

lib/dialects/sqlite/index.js

@@ -20,11 +20,13 @@ var SqliteDialect = function(sequelize) {
 SqliteDialect.prototype.supports = _.merge(_.cloneDeep(Abstract.prototype.supports), {
   'DEFAULT': false,
   'DEFAULT VALUES': true,
+  'UNION ALL': false,
   'IGNORE': ' OR IGNORE',
   index: {
     using: false
   },
-  joinTableDependent: false
+  joinTableDependent: false,
+  groupedLimit: false
 });
 
 SqliteDialect.prototype.Query = Query;

lib/model.js

@@ -584,15 +584,15 @@ validateIncludedElement = function(include, tableNames, options) {
     include.where = include.where ? { $and: [include.where, include.association.scope] }:  include.association.scope;
   }
 
-  if (include.limit && include.seperate === undefined) {
-    include.seperate = true;
+  if (include.limit && include.separate === undefined) {
+    include.separate = true;
   }
 
-  if (include.seperate === true && !(include.association instanceof HasMany)) {
-    throw new Error('Only HasMany associations support include.seperate');
+  if (include.separate === true && !(include.association instanceof HasMany)) {
+    throw new Error('Only HasMany associations support include.separate');
   }
 
-  if (include.seperate === true) {
+  if (include.separate === true) {
     include.duplicating = false;
   }
 
@@ -1191,6 +1191,8 @@ Model.prototype.all = function(options) {
  * @param  {Object}                    [options.include[].where] Where clauses to apply to the child models. Note that this converts the eager load to an inner join, unless you explicitly set `required: false`
  * @param  {Array<String>}             [options.include[].attributes] A list of attributes to select from the child model
  * @param  {Boolean}                   [options.include[].required] If true, converts to an inner join, which means that the parent model will only be loaded if it has any matching children. True if `include.where` is set, false otherwise.
+ * @param  {Boolean}                   [options.include[].separate] If true, runs a separate query to fetch the associated instances, only supported for hasMany associations
+ * @param  {Number}                    [options.include[].limit] Limit the joined rows, only supported with include.separate=true
  * @param  {Object}                    [options.include[].through.where] Filter on the join model for belongsToMany relations
  * @param  {Array}                     [options.include[].through.attributes] A list of attributes to select from the join model for belongsToMany relations
  * @param  {Array<Object|Model>}       [options.include[].include] Load further nested related models
@@ -1269,6 +1271,7 @@ Model.prototype.findAll = function(options) {
   }).then(function() {
     originalOptions = optClone(options);
     options.tableNames = Object.keys(tableNames);
+
     return this.QueryInterface.select(this, this.getTableName(options), options);
   }).tap(function(results) {
     if (options.hooks) {
@@ -1286,7 +1289,7 @@ Model.$findSeperate = function(results, options) {
   if (options.plain) results = [results];
 
   return Promise.map(options.include, function (include) {
-    if (!include.seperate) {
+    if (!include.separate) {
       return Model.$findSeperate(
         results.reduce(function (memo, result) {
           var associations = result.get(include.association.as);

lib/query-interface.js

@@ -678,6 +678,7 @@ QueryInterface.prototype.select = function(model, tableName, options) {
   options = options || {};
   options.type = QueryTypes.SELECT;
   options.model = model;
+
   return this.sequelize.query(
     this.QueryGenerator.selectQuery(tableName, options, model),
     options

test/integration/associations/has-many.test.js

@@ -26,8 +26,8 @@ describe(Support.getTestDialectTeaser('HasMany'), function() {
     });
   });
 
-  describe('(1:N)', function() {
   describe('get', function () {
+    if (current.dialect.supports.groupedLimit) {
       describe('multiple', function () {
         it('should fetch associations for multiple instances', function () {
           var User = this.sequelize.define('User', {})
@@ -67,9 +67,119 @@ describe(Support.getTestDialectTeaser('HasMany'), function() {
             });
           });
         });
+
+        it('should fetch associations for multiple instances with limit and order', function () {
+          var User = this.sequelize.define('User', {})
+            , Task = this.sequelize.define('Task', {
+                title: DataTypes.STRING
+              });
+
+          User.Tasks = User.hasMany(Task, {as: 'tasks'});
+
+          return this.sequelize.sync({force: true}).then(function () {
+            return Promise.join(
+              User.create({
+                tasks: [
+                  {title: 'b'},
+                  {title: 'd'},
+                  {title: 'c'},
+                  {title: 'a'}
+                ]
+              }, {
+                include: [User.Tasks]
+              }),
+              User.create({
+                tasks: [
+                  {title: 'a'},
+                  {title: 'c'},
+                  {title: 'b'}
+                ]
+              }, {
+                include: [User.Tasks]
+              })
+            );
+          }).then(function (users) {
+            return User.Tasks.get(users, {
+              limit: 2,
+              order: [
+                ['title', 'ASC']
+              ]
+            }).then(function (result) {
+              expect(result[users[0].id].length).to.equal(2);
+              expect(result[users[0].id][0].title).to.equal('a');
+              expect(result[users[0].id][1].title).to.equal('b');
+
+              expect(result[users[1].id].length).to.equal(2);
+              expect(result[users[1].id][0].title).to.equal('a');
+              expect(result[users[1].id][1].title).to.equal('b');
+            });
           });
         });
 
+        it('should fetch associations for multiple instances with limit and order and a belongsTo relation', function () {
+          var User = this.sequelize.define('User', {})
+            , Task = this.sequelize.define('Task', {
+                title: DataTypes.STRING,
+                categoryId: {
+                  type: DataTypes.INTEGER,
+                  field: 'category_id'
+                }
+              })
+            , Category = this.sequelize.define('Category', {});
+
+          User.Tasks = User.hasMany(Task, {as: 'tasks'});
+          Task.Category = Task.belongsTo(Category, {as: 'category', foreignKey: 'categoryId'});
+
+          return this.sequelize.sync({force: true}).then(function () {
+            return Promise.join(
+              User.create({
+                tasks: [
+                  {title: 'b', category: {}},
+                  {title: 'd', category: {}},
+                  {title: 'c', category: {}},
+                  {title: 'a', category: {}}
+                ]
+              }, {
+                include: [{association: User.Tasks, include: [Task.Category]}]
+              }),
+              User.create({
+                tasks: [
+                  {title: 'a', category: {}},
+                  {title: 'c', category: {}},
+                  {title: 'b', category: {}}
+                ]
+              }, {
+                include: [{association: User.Tasks, include: [Task.Category]}]
+              })
+            );
+          }).then(function (users) {
+            return User.Tasks.get(users, {
+              limit: 2,
+              order: [
+                ['title', 'ASC']
+              ],
+              include: [Task.Category],
+            }).then(function (result) {
+              expect(result[users[0].id].length).to.equal(2);
+              expect(result[users[0].id][0].title).to.equal('a');
+              expect(result[users[0].id][0].category).to.be.ok;
+              expect(result[users[0].id][1].title).to.equal('b');
+              expect(result[users[0].id][1].category).to.be.ok;
+
+              expect(result[users[1].id].length).to.equal(2);
+              expect(result[users[1].id][0].title).to.equal('a');
+              expect(result[users[1].id][0].category).to.be.ok;
+              expect(result[users[1].id][1].title).to.equal('b');
+              expect(result[users[1].id][1].category).to.be.ok;
+            });
+          });
+        });
+      });
+    }
+  });
+
+  describe('(1:N)', function() {
+
     describe('hasSingle', function() {
       beforeEach(function() {
         this.Article = this.sequelize.define('Article', { 'title': DataTypes.STRING });

test/integration/include/seperate.test.js

@@ -6,11 +6,13 @@ var chai = require('chai')
   , sinon = require('sinon')
   , Support = require(__dirname + '/../support')
   , Sequelize = require(__dirname + '/../../../index')
+  , current = Support.sequelize
   , Promise = Sequelize.Promise;
 
-describe(Support.getTestDialectTeaser('Include'), function() {
-  describe('seperate', function () {
-    it('should run a hasMany association in a seperate query', function () {
+if (current.dialect.supports.groupedLimit) {
+  describe(Support.getTestDialectTeaser('Include'), function() {
+    describe('separate', function () {
+      it('should run a hasMany association in a separate query', function () {
         var User = this.sequelize.define('User', {})
           , Task = this.sequelize.define('Task', {})
           , sqlSpy = sinon.spy();
@@ -40,7 +42,7 @@ describe(Support.getTestDialectTeaser('Include'), function() {
           ).then(function () {
             return User.findAll({
               include: [
-              {association: User.Tasks, seperate: true}
+                {association: User.Tasks, separate: true}
               ],
               order: [
                 ['id', 'ASC']
@@ -57,7 +59,57 @@ describe(Support.getTestDialectTeaser('Include'), function() {
         });
       });
 
-    it('should run a nested (from a non-seperate include) hasMany association in a seperate query', function () {
+      it('should run a hasMany association with limit in a separate query', function () {
+        var User = this.sequelize.define('User', {})
+          , Task = this.sequelize.define('Task', {})
+          , sqlSpy = sinon.spy();
+
+        User.Tasks = User.hasMany(Task, {as: 'tasks'});
+
+        return this.sequelize.sync({force: true}).then(function () {
+          return Promise.join(
+            User.create({
+              id: 1,
+              tasks: [
+                {},
+                {},
+                {}
+              ]
+            }, {
+              include: [User.Tasks]
+            }),
+            User.create({
+              id: 2,
+              tasks: [
+                {},
+                {},
+                {},
+                {}
+              ]
+            }, {
+              include: [User.Tasks]
+            })
+          ).then(function () {
+            return User.findAll({
+              include: [
+                {association: User.Tasks, limit: 2}
+              ],
+              order: [
+                ['id', 'ASC']
+              ],
+              logging: sqlSpy
+            });
+          }).then(function (users) {
+            expect(users[0].get('tasks')).to.be.ok;
+            expect(users[0].get('tasks').length).to.equal(2);
+            expect(users[1].get('tasks')).to.be.ok;
+            expect(users[1].get('tasks').length).to.equal(2);
+            expect(sqlSpy).to.have.been.calledTwice;
+          });
+        });
+      });
+
+      it('should run a nested (from a non-separate include) hasMany association in a separate query', function () {
         var User = this.sequelize.define('User', {})
           , Company = this.sequelize.define('Company')
           , Task = this.sequelize.define('Task', {})
@@ -98,7 +150,7 @@ describe(Support.getTestDialectTeaser('Include'), function() {
             return User.findAll({
               include: [
                 {association: User.Company, include: [
-                {association: Company.Tasks, seperate: true}
+                  {association: Company.Tasks, separate: true}
                 ]}
               ],
               order: [
@@ -116,7 +168,7 @@ describe(Support.getTestDialectTeaser('Include'), function() {
         });
       });
 
-    it('should run two nested hasMany association in a seperate queries', function () {
+      it('should run two nested hasMany association in a separate queries', function () {
         var User = this.sequelize.define('User', {})
           , Project = this.sequelize.define('Project', {})
           , Task = this.sequelize.define('Task', {})
@@ -169,8 +221,8 @@ describe(Support.getTestDialectTeaser('Include'), function() {
           ).then(function () {
             return User.findAll({
               include: [
-              {association: User.Projects, seperate: true, include: [
-                {association: Project.Tasks, seperate: true}
+                {association: User.Projects, separate: true, include: [
+                  {association: Project.Tasks, separate: true}
                 ]}
               ],
               order: [
@@ -196,4 +248,5 @@ describe(Support.getTestDialectTeaser('Include'), function() {
         });
       });
     });
-});
\ No newline at end of file
+  });
+}
\ No newline at end of file

test/unit/sql/select.test.js

@@ -60,11 +60,11 @@ suite(Support.getTestDialectTeaser('SQL'), function() {
         ]
       }
     }, {
-      default: 'SELECT * FROM ('+
+      default: 'SELECT [User].* FROM ('+
         [
-          '(SELECT [email], [first_name] AS [firstName], [last_name] AS [lastName] FROM [User] WHERE [User].[companyId] = 1 ORDER BY [last_name] ASC LIMIT 3)',
-          '(SELECT [email], [first_name] AS [firstName], [last_name] AS [lastName] FROM [User] WHERE [User].[companyId] = 5 ORDER BY [last_name] ASC LIMIT 3)'
-        ].join(' UNION ALL ')
+          '(SELECT [email], [first_name] AS [firstName], [last_name] AS [lastName] FROM [User] WHERE [User].[companyId] = 1 ORDER BY [last_name] ASC'+sql.addLimitAndOffset({ limit: 3, order: ['last_name', 'ASC'] })+')',
+          '(SELECT [email], [first_name] AS [firstName], [last_name] AS [lastName] FROM [User] WHERE [User].[companyId] = 5 ORDER BY [last_name] ASC'+sql.addLimitAndOffset({ limit: 3, order: ['last_name', 'ASC'] })+')'
+        ].join(current.dialect.supports['UNION ALL'] ?' UNION ALL ' : ' UNION ')
       +') AS [User];'
     });
 
@@ -132,11 +132,11 @@ suite(Support.getTestDialectTeaser('SQL'), function() {
           ]
         }
       }, {
-        default: 'SELECT * FROM ('+
+        default: 'SELECT [user].*, [POSTS].[id] AS [POSTS.id], [POSTS].[title] AS [POSTS.title] FROM ('+
           [
-            '(SELECT [id_user] AS [id], [email], [first_name] AS [firstName], [last_name] AS [lastName] FROM [users] WHERE [users].[companyId] = 1 ORDER BY [last_name] ASC LIMIT 3)',
-            '(SELECT [id_user] AS [id], [email], [first_name] AS [firstName], [last_name] AS [lastName] FROM [users] WHERE [users].[companyId] = 5 ORDER BY [last_name] ASC LIMIT 3)'
-          ].join(' UNION ALL ')
+            '(SELECT [id_user] AS [id], [email], [first_name] AS [firstName], [last_name] AS [lastName] FROM [users] AS [user] WHERE [user].[companyId] = 1 ORDER BY [user].[last_name] ASC'+sql.addLimitAndOffset({ limit: 3, order: ['last_name', 'ASC'] })+')',
+            '(SELECT [id_user] AS [id], [email], [first_name] AS [firstName], [last_name] AS [lastName] FROM [users] AS [user] WHERE [user].[companyId] = 5 ORDER BY [user].[last_name] ASC'+sql.addLimitAndOffset({ limit: 3, order: ['last_name', 'ASC'] })+')'
+          ].join(current.dialect.supports['UNION ALL'] ?' UNION ALL ' : ' UNION ')
         +') AS [user] LEFT OUTER JOIN [post] AS [POSTS] ON [user].[id] = [POSTS].[user_id];'
       });
     })();