Merge branch 'master' into milestones/2.0.0

.editorconfig

+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+
+# Change these settings to your own preference
+indent_style = space
+indent_size = 2
+
+# We recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+
+[*.md]
+trim_trailing_whitespace = false
+indent_size = 4

.npmignore

+docs
+examples
+test
+README.md
+.watchr.js
+changelog.md
+Makefile
\ No newline at end of file

changelog.md

@@ -86,6 +86,7 @@
 - [FEATURE] Support for literals and casts. [#950](https://github.com/sequelize/sequelize/pull/950). Thanks to durango.
 - [FEATURE] Model#findOrBuild. [#960](https://github.com/sequelize/sequelize/pull/960). Thanks to durango.
 - [FEATURE] Support for MariaDB. [#948](https://github.com/sequelize/sequelize/pull/948). Thanks to reedog117 and janmeier.
+- [FEATURE] Filter through associations. [#991](https://github.com/sequelize/sequelize/pull/991). Thanks to snit-ram.
 - [REFACTORING] hasMany now uses a single SQL statement when creating and destroying associations, instead of removing each association seperately [690](https://github.com/sequelize/sequelize/pull/690). Inspired by [#104](https://github.com/sequelize/sequelize/issues/104). janmeier
 - [REFACTORING] Consistent handling of offset across dialects. Offset is now always applied, and limit is set to max table size of not limit is given [#725](https://github.com/sequelize/sequelize/pull/725). janmeier
 - [REFACTORING] Moved Jasmine to Buster and then Buster to Mocha + Chai. sdepold and durango

lib/dialects/abstract/query-generator.js

@@ -98,23 +98,6 @@ module.exports = (function() {
     },
 
     /*
-      Returns a query for selecting elements in the table <tableName>.
-      Options:
-        - attributes -> An array of attributes (e.g. ['name', 'birthday']). Default: *
-        - where -> A hash with conditions (e.g. {name: 'foo'})
-                   OR an ID as integer
-                   OR a string with conditions (e.g. 'name="foo"').
-                   If you use a string, you have to escape it on your own.
-        - order -> e.g. 'id DESC'
-        - group
-        - limit -> The maximum count you want to get.
-        - offset -> An offset value to start from. Only useable with limit!
-    */
-    selectQuery: function(tableName, options) {
-      throwMethodUndefined('selectQuery')
-    },
-
-    /*
       Returns an insert into command. Parameters: table name + hash of attribute-value-pairs.
     */
     insertQuery: function(tableName, attrValueHash) {
@@ -231,21 +214,6 @@ module.exports = (function() {
     },
 
     /*
-      Takes something and transforms it into values of a where condition.
-    */
-    getWhereConditions: function(smth) {
-      throwMethodUndefined('getWhereConditions')
-    },
-
-    /*
-      Takes a hash and transforms it into a mysql where condition: {key: value, key2: value2} ==> key=value AND key2=value2
-      The values are transformed by the relevant datatype.
-    */
-    hashToWhereConditions: function(hash) {
-      throwMethodUndefined('hashToWhereConditions')
-    },
-
-    /*
       This method transforms an array of attribute hashes into equivalent
       sql attribute definition.
     */
@@ -376,6 +344,344 @@ module.exports = (function() {
      */
     dropForeignKeyQuery: function(tableName, foreignKey) {
       throwMethodUndefined('dropForeignKeyQuery')
+    },
+
+
+    /*
+      Returns a query for selecting elements in the table <tableName>.
+      Options:
+        - attributes -> An array of attributes (e.g. ['name', 'birthday']). Default: *
+        - where -> A hash with conditions (e.g. {name: 'foo'})
+                   OR an ID as integer
+                   OR a string with conditions (e.g. 'name="foo"').
+                   If you use a string, you have to escape it on your own.
+        - order -> e.g. 'id DESC'
+        - group
+        - limit -> The maximum count you want to get.
+        - offset -> An offset value to start from. Only useable with limit!
+    */
+    selectQuery: function(tableName, options, factory) {
+      var table = null,
+          joinQuery = ""
+
+      options            = options || {}
+      options.table      = table = Array.isArray(tableName) ? tableName.map(function(t) { return this.quoteIdentifiers(t) }.bind(this)).join(", ") : this.quoteIdentifiers(tableName)
+      options.attributes = options.attributes && options.attributes.map(function(attr){
+        if(Array.isArray(attr) && attr.length == 2) {
+          return [attr[0], this.quoteIdentifier(attr[1])].join(' as ')
+        } else {
+          return attr.indexOf(Utils.TICK_CHAR) < 0 && attr.indexOf('"') < 0 ? this.quoteIdentifiers(attr) : attr
+        }
+      }.bind(this)).join(", ")
+      options.attributes = options.attributes || '*'
+
+      if (options.include) {
+        var optAttributes = options.attributes === '*' ? [options.table + '.*'] : [options.attributes]
+
+        options.include.forEach(function(include) {
+          var attributes = include.attributes.map(function(attr) {
+            return this.quoteIdentifier(include.as) + "." + this.quoteIdentifier(attr) + " AS " + this.quoteIdentifier(include.as + "." + attr)
+          }.bind(this))
+
+          optAttributes = optAttributes.concat(attributes)
+
+          var table = include.daoFactory.tableName
+            , as    = include.as
+
+          if (!include.association.connectorDAO) {
+            var primaryKeysLeft = ((include.association.associationType === 'BelongsTo') ? Object.keys(include.association.target.primaryKeys) : Object.keys(include.association.source.primaryKeys))
+              , tableLeft       = ((include.association.associationType === 'BelongsTo') ? include.as : tableName)
+              , attrLeft        = ((primaryKeysLeft.length !== 1) ? 'id' : primaryKeysLeft[0])
+              , tableRight      = ((include.association.associationType === 'BelongsTo') ? tableName : include.as)
+              , attrRight       = include.association.identifier
+
+            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(table) + " AS " + this.quoteIdentifier(as) + " ON " + this.quoteIdentifier(tableLeft) + "." + this.quoteIdentifier(attrLeft) + " = " + this.quoteIdentifier(tableRight) + "." + this.quoteIdentifier(attrRight)
+          } else {
+            var primaryKeysSource = Object.keys(include.association.source.primaryKeys)
+              , tableSource       = tableName
+              , identSource       = include.association.identifier
+              , attrSource        = ((!include.association.source.hasPrimaryKeys || primaryKeysSource.length !== 1) ? 'id' : primaryKeysSource[0])
+
+            var primaryKeysTarget = Object.keys(include.association.target.primaryKeys)
+              , tableTarget       = include.as
+              , identTarget       = include.association.foreignIdentifier
+              , attrTarget        = ((!include.association.target.hasPrimaryKeys || primaryKeysTarget.length !== 1) ? 'id' : primaryKeysTarget[0])
+
+            var tableJunction     = include.association.connectorDAO.tableName
+            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(tableJunction) + " ON " + this.quoteIdentifier(tableSource) + "." + this.quoteIdentifier(attrSource) + " = " + this.quoteIdentifier(tableJunction) + "." + this.quoteIdentifier(identSource)
+            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(table) + " AS " + this.quoteIdentifier(as) + " ON " + this.quoteIdentifier(tableTarget) + "." + this.quoteIdentifier(attrTarget) + " = " + this.quoteIdentifier(tableJunction) + "." + this.quoteIdentifier(identTarget)
+          }
+        }.bind(this))
+
+        options.attributes = optAttributes.join(', ')
+      }
+
+      var conditionalJoins = this.getConditionalJoins(options, factory),
+        query;
+
+      if (conditionalJoins) {
+        query = "SELECT " + options.attributes + " FROM ( "
+          + "SELECT " + options.table + ".* FROM " + options.table + this.getConditionalJoins(options, factory)
+      } else {
+        query = "SELECT " + options.attributes + " FROM " + options.table
+        query += joinQuery
+      }
+
+      if (options.hasOwnProperty('where')) {
+        options.where = this.getWhereConditions(options.where, tableName, factory)
+        query += " WHERE " + options.where
+      }
+
+      if (options.group) {
+        options.group = Array.isArray(options.group) ? options.group.map(function (t) { return this.quote(t) }.bind(this)).join(', ') : options.group
+        query += " GROUP BY " + options.group
+      }
+
+      if (options.order) {
+        options.order = Array.isArray(options.order) ? options.order.map(function (t) { return this.quote(t) }.bind(this)).join(', ') : options.order
+        query += " ORDER BY " + options.order
+      }
+
+      query = this.addLimitAndOffset(options, query)
+
+      if (conditionalJoins) {
+        query += ") AS " + options.table
+        query += joinQuery
+      }
+
+      query += ";"
+
+      return query
+    },
+
+    addLimitAndOffset: function(options, query){
+      if (options.offset && !options.limit) {
+        query += " LIMIT " + options.offset + ", " + 10000000000000;
+      } else if (options.limit && !(options.include && (options.limit === 1))) {
+        if (options.offset) {
+          query += " LIMIT " + options.offset + ", " + options.limit
+        } else {
+          query += " LIMIT " + options.limit
+        }
+      }
+      return query;
+    },
+
+    /*
+      Takes something and transforms it into values of a where condition.
+    */
+    getWhereConditions: function(smth, tableName, factory) {
+      var result = null
+        , where = {}
+
+      if (Utils.isHash(smth)) {
+        smth   = Utils.prependTableNameToHash(tableName, smth)
+        result = this.hashToWhereConditions(smth, factory)
+      } else if (typeof smth === 'number') {
+        var primaryKeys = !!factory ? Object.keys(factory.primaryKeys) : []
+        if (primaryKeys.length > 0) {
+          // Since we're just a number, assume only the first key
+          primaryKeys = primaryKeys[0]
+        } else {
+          primaryKeys = 'id'
+        }
+
+        where[primaryKeys] = smth
+        smth   = Utils.prependTableNameToHash(tableName, where)
+        result = this.hashToWhereConditions(smth)
+      } else if (typeof smth === "string") {
+        result = smth
+      } else if (Array.isArray(smth)) {
+        result = Utils.format(smth, this.dialect)
+      }
+
+      return result ? result : '1=1'
+    },
+
+    findAssociation: function(attribute, dao){
+      var associationToReturn;
+
+      Object.keys(dao.associations).forEach(function(key){
+        if(!dao.associations[key]) return;
+
+
+        var association = dao.associations[key]
+          , associationName
+
+        if (association.associationType === 'BelongsTo') {
+          associationName = Utils.singularize(association.associationAccessor[0].toLowerCase() + association.associationAccessor.slice(1));
+        } else {
+          associationName = association.accessors.get.replace('get', '')
+          associationName = associationName[0].toLowerCase() + associationName.slice(1);
+        }
+
+        if(associationName === attribute){
+          associationToReturn = association;
+        }
+      });
+
+      return associationToReturn;
+    },
+
+    getAssociationFilterDAO: function(filterStr, dao){
+      var associationParts = filterStr.split('.')
+        , self = this
+
+      associationParts.pop()
+
+      associationParts.forEach(function (attribute) {
+        dao = self.findAssociation(attribute, dao).target;
+      });
+
+      return dao;
+    },
+
+    isAssociationFilter: function(filterStr, dao){
+      if(!dao){
+        return false;
+      }
+
+      var pattern = /^[a-z][a-zA-Z0-9]+(\.[a-z][a-zA-Z0-9]+)+$/;
+      if (!pattern.test(filterStr)) return false;
+
+      var associationParts = filterStr.split('.')
+        , attributePart = associationParts.pop()
+        , self = this
+
+
+      return associationParts.every(function (attribute) {
+        var association = self.findAssociation(attribute, dao);
+        if (!association) return false;
+        dao = association.target;
+        return !!dao;
+      }) && dao.rawAttributes.hasOwnProperty(attributePart);
+    },
+
+    getAssociationFilterColumn: function(filterStr, dao){
+      var associationParts = filterStr.split('.')
+        , attributePart = associationParts.pop()
+        , self = this
+
+      associationParts.forEach(function (attribute) {
+        dao = self.findAssociation(attribute, dao).target;
+      })
+
+      return dao.tableName + '.' +  attributePart;
+    },
+
+    getConditionalJoins: function(options, originalDao){
+      var joins = ''
+        , self = this
+        , joinedTables = {}
+
+      if (Utils.isHash(options.where)) {
+        Object.keys(options.where).forEach(function(filterStr){
+          var associationParts = filterStr.split('.')
+            , attributePart = associationParts.pop()
+            , dao = originalDao
+
+          if (self.isAssociationFilter(filterStr, dao)) {
+            associationParts.forEach(function (attribute) {
+              var association = self.findAssociation(attribute, dao);
+
+              if(!joinedTables[association.target.tableName]){
+                joinedTables[association.target.tableName] = true;
+
+                if(association.associationType === 'BelongsTo'){
+                  joins += ' LEFT JOIN ' + self.quoteIdentifiers(association.target.tableName)
+                  joins += ' ON ' + self.quoteIdentifiers(association.source.tableName + '.' + association.identifier)
+                  joins += ' = ' + self.quoteIdentifiers(association.target.tableName + '.' + association.target.autoIncrementField)
+                } else if (association.connectorDAO){
+                  joinedTables[association.connectorDAO.tableName] = true;
+                  joins += ' LEFT JOIN ' + self.quoteIdentifiers(association.connectorDAO.tableName)
+                  joins += ' ON ' + self.quoteIdentifiers(association.source.tableName + '.' + association.source.autoIncrementField)
+                  joins += ' = ' + self.quoteIdentifiers(association.connectorDAO.tableName + '.' + association.identifier)
+
+                  joins += ' LEFT JOIN ' + self.quoteIdentifiers(association.target.tableName)
+                  joins += ' ON ' + self.quoteIdentifiers(association.connectorDAO.tableName + '.' + association.foreignIdentifier)
+                  joins += ' = ' + self.quoteIdentifiers(association.target.tableName + '.' + association.target.autoIncrementField)
+                } else {
+                  joins += ' LEFT JOIN ' + self.quoteIdentifiers(association.target.tableName)
+                  joins += ' ON ' + self.quoteIdentifiers(association.source.tableName + '.' + association.source.autoIncrementField)
+                  joins += ' = ' + self.quoteIdentifiers(association.target.tableName + '.' + association.identifier)
+                }
+              }
+              dao = association.target;
+            });
+          }
+        });
+      }
+
+      return joins;
+    },
+
+    arrayValue: function(value, key, _key){
+        var _value = null;
+
+        if (value.length === 0) { value = [null] }
+        _value = "(" + value.map(function(v) { return this.escape(v) }.bind(this)).join(',') + ")"
+        return [_key, _value].join(" IN ")
+    },
+
+    /*
+      Takes a hash and transforms it into a mysql where condition: {key: value, key2: value2} ==> key=value AND key2=value2
+      The values are transformed by the relevant datatype.
+    */
+    hashToWhereConditions: function(hash, dao) {
+      var result = []
+
+      for (var key in hash) {
+        var value = hash[key]
+
+        if(this.isAssociationFilter(key, dao)){
+          key = this.getAssociationFilterColumn(key, dao);
+        }
+
+         //handle qualified key names
+        var _key   = this.quoteIdentifiers(key)
+          , _value = null
+
+        if (Array.isArray(value)) {
+          result.push(this.arrayValue(value, key, _key, dao))
+        } else if ((value) && (typeof value == 'object') && !(value instanceof Date)) {
+          if (!!value.join) {
+            //using as sentinel for join column => value
+            _value = this.quoteIdentifiers(value.join)
+            result.push([_key, _value].join("="))
+          } else {
+            for (var logic in value) {
+              var logicResult = Utils.getWhereLogic(logic)
+              if (logic === "IN" || logic === "NOT IN") {
+                var values = Array.isArray(where[i][ii]) ? where[i][ii] : [where[i][ii]]
+                _where[_where.length] = i + ' ' + logic + ' (' + values.map(function(){ return '?' }).join(',') + ')'
+                _whereArgs = _whereArgs.concat(values)
+              }
+              else if (logicResult === "BETWEEN" || logicResult === "NOT BETWEEN") {
+                _value = this.escape(value[logic][0])
+                var _value2 = this.escape(value[logic][1])
+
+                result.push(' (' + _key + ' ' + logicResult + ' ' + _value + ' AND ' + _value2 + ') ')
+              } else {
+                _value = this.escape(value[logic])
+                result.push([_key, _value].join(' ' + logicResult + ' '))
+              }
+            }
+          }
+        } else {
+          if (typeof value === 'boolean') {
+            _value = this.booleanValue(value);
+          } else {
+            _value = this.escape(value)
+          }
+          result.push((_value == 'NULL') ? _key + " IS NULL" : [_key, _value].join("="))
+        }
+      }
+
+      return result.join(" AND ")
+    },
+
+    booleanValue: function(value){
+      return value;
     }
   }
 

lib/dialects/mysql/query-generator.js

@@ -162,100 +162,6 @@ module.exports = (function() {
       return Utils._.template(query)({ tableName: tableName, attributes: attrString.join(', ') })
     },
 
-    selectQuery: function(tableName, options, factory) {
-      var table = null,
-          joinQuery = ""
-
-      options            = options || {}
-      options.table      = table = Array.isArray(tableName) ? tableName.map(function(t) { return this.quoteIdentifier(t)}.bind(this)).join(", ") : this.quoteIdentifier(tableName)
-      options.attributes = options.attributes && options.attributes.map(function(attr){
-        if(Array.isArray(attr) && attr.length == 2) {
-          return [attr[0], this.quoteIdentifier(attr[1])].join(' as ')
-        } else {
-          return attr.indexOf(Utils.TICK_CHAR) < 0 ? this.quoteIdentifiers(attr) : attr
-        }
-      }.bind(this)).join(", ")
-      options.attributes = options.attributes || '*'
-
-      if (options.include) {
-        var optAttributes = options.attributes === '*' ? [options.table + '.*'] : [options.attributes]
-
-        options.include.forEach(function(include) {
-          var attributes = include.attributes.map(function(attr) {
-            return this.quoteIdentifier(include.as) + "." + this.quoteIdentifier(attr) + " AS " + this.quoteIdentifier(include.as + "." + attr)
-          }.bind(this))
-
-          optAttributes = optAttributes.concat(attributes)
-
-          var table = include.daoFactory.tableName
-            , as    = include.as
-
-          if (!include.association.connectorDAO) {
-            var primaryKeysLeft = ((include.association.associationType === 'BelongsTo') ? Object.keys(include.association.target.primaryKeys) : Object.keys(include.association.source.primaryKeys))
-              , tableLeft       = ((include.association.associationType === 'BelongsTo') ? include.as : tableName)
-              , attrLeft        = ((primaryKeysLeft.length !== 1) ? 'id' : primaryKeysLeft[0])
-              , tableRight      = ((include.association.associationType === 'BelongsTo') ? tableName : include.as)
-              , attrRight       = include.association.identifier
-
-            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(table) + " AS " + this.quoteIdentifier(as) + " ON " + this.quoteIdentifier(tableLeft) + "." + this.quoteIdentifier(attrLeft) + " = " + this.quoteIdentifier(tableRight) + "." + this.quoteIdentifier(attrRight)
-          } else {
-            var primaryKeysSource = Object.keys(include.association.source.primaryKeys)
-              , tableSource       = tableName
-              , identSource       = include.association.identifier
-              , attrSource        = ((!include.association.source.hasPrimaryKeys || primaryKeysSource.length !== 1) ? 'id' : primaryKeysSource[0])
-
-            var primaryKeysTarget = Object.keys(include.association.target.primaryKeys)
-              , tableTarget       = include.as
-              , identTarget       = include.association.foreignIdentifier
-              , attrTarget        = ((!include.association.target.hasPrimaryKeys || primaryKeysTarget.length !== 1) ? 'id' : primaryKeysTarget[0])
-
-            var tableJunction     = include.association.connectorDAO.tableName
-            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(tableJunction) + " ON " + this.quoteIdentifier(tableSource) + "." + this.quoteIdentifier(attrSource) + " = " + this.quoteIdentifier(tableJunction) + "." + this.quoteIdentifier(identSource)
-            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(table) + " AS " + this.quoteIdentifier(as) + " ON " + this.quoteIdentifier(tableTarget) + "." + this.quoteIdentifier(attrTarget) + " = " + this.quoteIdentifier(tableJunction) + "." + this.quoteIdentifier(identTarget)
-          }
-        }.bind(this))
-
-        options.attributes = optAttributes.join(', ')
-      }
-
-      var query = "SELECT " + options.attributes + " FROM " + options.table
-      query += joinQuery
-
-      if (options.hasOwnProperty('where')) {
-        options.where = this.getWhereConditions(options.where, tableName, factory)
-        query += " WHERE " + options.where
-      }
-
-      if (options.group) {
-        options.group = Array.isArray(options.group) ? options.group.map(function (t) { return this.quote(t) }.bind(this)).join(', ') : options.group
-        query += " GROUP BY " + options.group
-      }
-
-      if (options.order) {
-        options.order = Array.isArray(options.order) ? options.order.map(function (t) { return this.quote(t) }.bind(this)).join(', ') : options.order
-        query += " ORDER BY " + options.order
-      }
-
-      if (options.offset && !options.limit) {
-        /*
-         * If no limit is defined, our best bet is to use the max number of rows in a table. From the MySQL docs:
-         * There is a limit of 2^32 (~4.295E+09) rows in a MyISAM table. If you build MySQL with the --with-big-tables option,
-         * the row limitation is increased to (2^32)^2 (1.844E+19) rows.
-         */
-        query += " LIMIT " + options.offset + ", " + 18440000000000000000;
-      } else if (options.limit && !(options.include && (options.limit === 1))) {
-        if (options.offset) {
-          query += " LIMIT " + options.offset + ", " + options.limit
-        } else {
-          query += " LIMIT " + options.limit
-        }
-      }
-
-      query += ";"
-
-      return query
-    },
-
     insertQuery: function(tableName, attrValueHash) {
       attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
 
@@ -421,83 +327,6 @@ module.exports = (function() {
       return Utils._.template(sql)({ tableName: tableName, indexName: indexName })
     },
 
-    getWhereConditions: function(smth, tableName, factory) {
-      var result = null
-        , where = {}
-
-      if (Utils.isHash(smth)) {
-        smth   = Utils.prependTableNameToHash(tableName, smth)
-        result = this.hashToWhereConditions(smth)
-      } else if (typeof smth === 'number') {
-        var primaryKeys = !!factory ? Object.keys(factory.primaryKeys) : []
-        if (primaryKeys.length > 0) {
-          // Since we're just a number, assume only the first key
-          primaryKeys = primaryKeys[0]
-        } else {
-          primaryKeys = 'id'
-        }
-
-        where[primaryKeys] = smth
-        smth   = Utils.prependTableNameToHash(tableName, where)
-        result = this.hashToWhereConditions(smth)
-      } else if (typeof smth === "string") {
-        result = smth
-      } else if (Array.isArray(smth)) {
-        result = Utils.format(smth, this.dialect)
-      }
-
-      return result ? result : '1=1'
-    },
-
-    hashToWhereConditions: function(hash) {
-      var result = []
-
-      for (var key in hash) {
-        var value = hash[key]
-
-         //handle qualified key names
-        var _key   = this.quoteIdentifiers(key)
-          , _value = null
-
-        if (Array.isArray(value)) {
-          // is value an array?
-          if (value.length === 0) { value = [null] }
-          _value = "(" + value.map(function(v) { return this.escape(v) }.bind(this)).join(',') + ")"
-
-          result.push([_key, _value].join(" IN "))
-        } else if ((value) && (typeof value == 'object') && !(value instanceof Date)) {
-          if (!!value.join) {
-            //using as sentinel for join column => value
-            _value = this.quoteIdentifiers(value.join)
-            result.push([_key, _value].join("="))
-          } else {
-            for (var logic in value) {
-              var logicResult = Utils.getWhereLogic(logic)
-              if (logic === "IN" || logic === "NOT IN") {
-                var values = Array.isArray(where[i][ii]) ? where[i][ii] : [where[i][ii]]
-                _where[_where.length] = i + ' ' + logic + ' (' + values.map(function(){ return '?' }).join(',') + ')'
-                _whereArgs = _whereArgs.concat(values)
-              }
-              else if (logicResult === "BETWEEN" || logicResult === "NOT BETWEEN") {
-                _value = this.escape(value[logic][0])
-                var _value2 = this.escape(value[logic][1])
-
-                result.push(' (' + _key + ' ' + logicResult + ' ' + _value + ' AND ' + _value2 + ') ')
-              } else {
-                _value = this.escape(value[logic])
-                result.push([_key, _value].join(' ' + logicResult + ' '))
-              }
-            }
-          }
-        } else {
-          _value = this.escape(value)
-          result.push((_value == 'NULL') ? _key + " IS NULL" : [_key, _value].join("="))
-        }
-      }
-
-      return result.join(" AND ")
-    },
-
     attributesToSQL: function(attributes) {
       var result = {}
 
@@ -588,6 +417,19 @@ module.exports = (function() {
       return fields
     },
 
+    addLimitAndOffset: function(options, query){
+      if (options.offset && !options.limit) {
+        query += " LIMIT " + options.offset + ", " + 18440000000000000000;
+      } else if (options.limit && !(options.include && (options.limit === 1))) {
+        if (options.offset) {
+          query += " LIMIT " + options.offset + ", " + options.limit
+        } else {
+          query += " LIMIT " + options.limit
+        }
+      }
+      return query;
+    },
+
     quoteIdentifier: function(identifier, force) {
       return Utils.addTicks(identifier, "`")
     },

lib/dialects/postgres/query-generator.js

@@ -144,6 +144,27 @@ module.exports = (function() {
         attributes: attrString.join(', ') })
     },
 
+    arrayValue: function(value, key, _key, factory){
+      if (value.length === 0) { value = [null] }
+      var col = null, coltype = null
+      // Special conditions for searching within an array column type
+      var _realKey = key.split('.').pop()
+      if (!!factory && !!factory.rawAttributes[_realKey]) {
+        col = factory.rawAttributes[_realKey]
+        coltype = col.type
+        if(coltype && !(typeof coltype == 'string')) {
+          coltype = coltype.toString();
+        }
+      }
+      if ( col && ((!!coltype && coltype.match(/\[\]$/) !== null) || (col.toString().match(/\[\]$/) !== null))) {
+        _value = 'ARRAY[' + value.map(this.escape).join(',') + ']::' + (!!col.type ? col.type : col.toString())
+        return [_key, _value].join(" && ")
+      } else {
+        _value = "(" + value.map(this.escape).join(',') + ")"
+        return [_key, _value].join(" IN ")
+      }
+    },
+
     removeColumnQuery: function(tableName, attributeName) {
       var query = "ALTER TABLE <%= tableName %> DROP COLUMN <%= attributeName %>;"
       return Utils._.template(query)({
@@ -230,100 +251,6 @@ module.exports = (function() {
       })
     },
 
-    selectQuery: function(tableName, options, factory) {
-      var query = "SELECT <%= attributes %> FROM <%= table %>",
-          table = null
-
-      options            = options || {}
-      options.table      = table = Array.isArray(tableName) ? tableName.map(function(t) { return this.quoteIdentifiers(t) }.bind(this)).join(", ") : this.quoteIdentifiers(tableName)
-      options.attributes = options.attributes && options.attributes.map(function(attr) {
-        if (Array.isArray(attr) && attr.length === 2) {
-          return [attr[0], this.quoteIdentifier(attr[1])].join(' as ')
-        } else {
-          return attr.indexOf('"') < 0 ? this.quoteIdentifiers(attr) : attr
-        }
-      }.bind(this)).join(", ")
-      options.attributes = options.attributes || '*'
-
-      if (options.include) {
-        var optAttributes = options.attributes === '*' ? [options.table + '.*'] : [options.attributes]
-
-        options.include.forEach(function(include) {
-          var attributes = include.attributes.map(function(attr) {
-            return this.quoteIdentifier(include.as) + "." + this.quoteIdentifier(attr) + " AS " + this.quoteIdentifier(include.as + "." + attr, true)
-          }.bind(this))
-
-          optAttributes = optAttributes.concat(attributes)
-
-          var joinQuery = ' LEFT OUTER JOIN <%= table %> AS <%= as %> ON <%= tableLeft %>.<%= attrLeft %> = <%= tableRight %>.<%= attrRight %>'
-
-          if (!include.association.connectorDAO) {
-            var primaryKeysLeft = ((include.association.associationType === 'BelongsTo') ? Object.keys(include.association.target.primaryKeys) : Object.keys(include.association.source.primaryKeys))
-            query += Utils._.template(joinQuery)({
-              table:      this.quoteIdentifiers(include.daoFactory.tableName),
-              as:         this.quoteIdentifier(include.as),
-              tableLeft:  this.quoteIdentifier((include.association.associationType === 'BelongsTo') ? include.as : tableName),
-              attrLeft:   this.quoteIdentifier(((primaryKeysLeft.length !== 1) ? 'id' : primaryKeysLeft[0])),
-              tableRight: this.quoteIdentifiers((include.association.associationType === 'BelongsTo') ? tableName : include.as),
-              attrRight:  this.quoteIdentifier(include.association.identifier)
-            })
-          } else {
-            var primaryKeysSource = Object.keys(include.association.source.primaryKeys)
-              , primaryKeysTarget = Object.keys(include.association.target.primaryKeys)
-
-            query += Utils._.template(joinQuery)({
-              table:      this.quoteIdentifiers(include.association.connectorDAO.tableName),
-              as:         this.quoteIdentifier(include.association.connectorDAO.tableName),
-              tableLeft:  this.quoteIdentifiers(tableName),
-              attrLeft:   this.quoteIdentifier(((!include.association.source.hasPrimaryKeys || primaryKeysSource.length !== 1) ? 'id' : primaryKeysSource[0])),
-              tableRight: this.quoteIdentifiers(include.association.connectorDAO.tableName),
-              attrRight:  this.quoteIdentifier(include.association.identifier)
-            })
-
-            query += Utils._.template(joinQuery)({
-              table:      this.quoteIdentifiers(include.daoFactory.tableName),
-              as:         this.quoteIdentifier(include.as),
-              tableLeft:  this.quoteIdentifiers(include.as),
-              attrLeft:   this.quoteIdentifier(((!include.association.target.hasPrimaryKeys || primaryKeysTarget.length !== 1) ? 'id' : primaryKeysTarget[0])),
-              tableRight: this.quoteIdentifiers(include.association.connectorDAO.tableName),
-              attrRight:  this.quoteIdentifier(include.association.foreignIdentifier)
-            })
-          }
-        }.bind(this))
-
-        options.attributes = optAttributes.join(', ')
-      }
-
-      if(options.hasOwnProperty('where')) {
-        options.where = this.getWhereConditions(options.where, tableName, factory)
-        query += " WHERE <%= where %>"
-      }
-
-      if(options.group) {
-        options.group = Array.isArray(options.group) ? options.group.map(function (t) { return this.quote(t) }.bind(this)).join(', ') : options.group
-        query += " GROUP BY <%= group %>"
-      }
-
-      if(options.order) {
-        options.order = Array.isArray(options.order) ? options.order.map(function (t) { return this.quote(t) }.bind(this)).join(', ') : options.order
-        query += " ORDER BY <%= order %>"
-      }
-
-      if (!(options.include && (options.limit === 1))) {
-        if (options.limit) {
-          query += " LIMIT <%= limit %>"
-        }
-
-        if (options.offset) {
-          query += " OFFSET <%= offset %>"
-        }
-      }
-
-      query += ";"
-
-      return Utils._.template(query)(options)
-    },
-
     insertQuery: function(tableName, attrValueHash, attributes) {
       attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
 
@@ -522,96 +449,18 @@ module.exports = (function() {
       })
     },
 
-    getWhereConditions: function(smth, tableName, factory) {
-      var result = null
-        , where = {}
-
-      if (Utils.isHash(smth)) {
-        smth = Utils.prependTableNameToHash(tableName, smth)
-        result = this.hashToWhereConditions(smth, factory)
-      } else if (typeof smth === 'number') {
-        var primaryKeys = !!factory ? Object.keys(factory.primaryKeys) : []
-        if (primaryKeys.length > 0) {
-          // Since we're just a number, assume only the first key
-          primaryKeys = primaryKeys[0]
-        } else {
-          primaryKeys = 'id'
-        }
-
-        where[primaryKeys] = smth
-        smth   = Utils.prependTableNameToHash(tableName, where)
-        result = this.hashToWhereConditions(smth)
-      } else if (typeof smth === "string") {
-        result = smth
-      }
-      else if (Array.isArray(smth)) {
-        result = Utils.format(smth, "postgres")
+    addLimitAndOffset: function(options, query){
+      if (!(options.include && (options.limit === 1))) {
+        if (options.limit) {
+          query += " LIMIT " + options.limit
         }
 
-      return result
-    },
-
-    hashToWhereConditions: function(hash, factory) {
-      var result = []
-
-      for (var key in hash) {
-        var value = hash[key]
-
-        //handle qualified key names
-        var _key   = this.quoteIdentifiers(key)
-          , _value = null
-
-        if (Array.isArray(value)) {
-          if (value.length === 0) { value = [null] }
-          var col = null, coltype = null
-          // Special conditions for searching within an array column type
-          var _realKey = key.split('.').pop()
-          if (!!factory && !!factory.rawAttributes[_realKey]) {
-            col = factory.rawAttributes[_realKey]
-            coltype = col.type
-            if(coltype && !(typeof coltype == 'string')) {
-              coltype = coltype.toString();
-            }
-          }
-          if ( col && ((!!coltype && coltype.match(/\[\]$/) !== null) || (col.toString().match(/\[\]$/) !== null))) {
-            _value = 'ARRAY[' + value.map(this.escape).join(',') + ']::' + (!!col.type ? col.type : col.toString())
-            result.push([_key, _value].join(" && "))
-          } else {
-            _value = "(" + value.map(this.escape).join(',') + ")"
-            result.push([_key, _value].join(" IN "))
-          }
-        }
-        else if ((value) && (typeof value === "object")) {
-          if (!!value.join) {
-            //using as sentinel for join column => value
-            _value = this.quoteIdentifiers(value.join)
-            result.push([_key, _value].join("="))
-          } else {
-            for (var logic in value) {
-              var logicResult = Utils.getWhereLogic(logic)
-              if (logic === "IN" || logic === "NOT IN") {
-                var values = Array.isArray(where[i][ii]) ? where[i][ii] : [where[i][ii]]
-                _where[_where.length] = i + ' ' + logic + ' (' + values.map(function(){ return '?' }).join(',') + ')'
-                _whereArgs = _whereArgs.concat(values)
-              }
-              else if (logicResult === "BETWEEN" || logicResult === "NOT BETWEEN") {
-                _value = this.escape(value[logic][0])
-                var _value2 = this.escape(value[logic][1])
-
-                result.push(' (' + _key + ' ' + logicResult + ' ' + _value + ' AND ' + _value2 + ') ')
-              } else {
-                _value = this.escape(value[logic])
-                result.push([_key, _value].join(' ' + logicResult + ' '))
-              }
-            }
-          }
-        } else {
-          _value = this.escape(value)
-          result.push((_value == 'NULL') ? _key + " IS NULL" : [_key, _value].join("="))
+        if (options.offset) {
+          query += " OFFSET " + options.offset
         }
       }
 
-      return result.join(' AND ')
+      return query;
     },
 
     attributesToSQL: function(attributes) {

lib/dialects/sqlite/query-generator.js

@@ -109,6 +109,10 @@ module.exports = (function() {
       return this.replaceBooleanDefaults(sql)
     },
 
+    booleanValue: function(value){
+      return !!value ? 1 : 0;
+    },
+
     dropTableQuery: function(tableName, options) {
       options = options || {}
 
@@ -119,6 +123,19 @@ module.exports = (function() {
       })
     },
 
+    addLimitAndOffset: function(options, query){
+      if (options.offset && !options.limit) {
+        query += " LIMIT " + options.offset + ", " + 10000000000000;
+      } else if (options.limit && !(options.include && (options.limit === 1))) {
+        if (options.offset) {
+          query += " LIMIT " + options.offset + ", " + options.limit
+        } else {
+          query += " LIMIT " + options.limit
+        }
+      }
+      return query;
+    },
+
     addColumnQuery: function() {
       var sql = MySqlQueryGenerator.addColumnQuery.apply(this, arguments)
       return this.replaceBooleanDefaults(sql)
@@ -165,100 +182,6 @@ module.exports = (function() {
       return Utils._.template(query)(replacements)
     },
 
-    selectQuery: function(tableName, options, factory) {
-      var table = null,
-          joinQuery = ""
-
-      options            = options || {}
-      options.table      = table = Array.isArray(tableName) ? tableName.map(function(t) { return this.quoteIdentifier(t)}.bind(this)).join(", ") : this.quoteIdentifier(tableName)
-      options.attributes = options.attributes && options.attributes.map(function(attr){
-        if(Array.isArray(attr) && attr.length == 2) {
-          return [attr[0], this.quoteIdentifier(attr[1])].join(' as ')
-        } else {
-          return attr.indexOf(Utils.TICK_CHAR) < 0 ? this.quoteIdentifiers(attr) : attr
-        }
-      }.bind(this)).join(", ")
-      options.attributes = options.attributes || '*'
-
-      if (options.include) {
-        var optAttributes = options.attributes === '*' ? [options.table + '.*'] : [options.attributes]
-
-        options.include.forEach(function(include) {
-          var attributes = include.attributes.map(function(attr) {
-            return this.quoteIdentifier(include.as) + "." + this.quoteIdentifier(attr) + " AS " + this.quoteIdentifier(include.as + "." + attr)
-          }.bind(this))
-
-          optAttributes = optAttributes.concat(attributes)
-
-          var table = include.daoFactory.tableName
-            , as    = include.as
-
-          if (!include.association.connectorDAO) {
-            var primaryKeysLeft = ((include.association.associationType === 'BelongsTo') ? Object.keys(include.association.target.primaryKeys) : Object.keys(include.association.source.primaryKeys))
-              , tableLeft       = ((include.association.associationType === 'BelongsTo') ? include.as : tableName)
-              , attrLeft        = ((primaryKeysLeft.length !== 1) ? 'id' : primaryKeysLeft[0])
-              , tableRight      = ((include.association.associationType === 'BelongsTo') ? tableName : include.as)
-              , attrRight       = include.association.identifier
-
-            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(table) + " AS " + this.quoteIdentifier(as) + " ON " + this.quoteIdentifier(tableLeft) + "." + this.quoteIdentifier(attrLeft) + " = " + this.quoteIdentifier(tableRight) + "." + this.quoteIdentifier(attrRight)
-          } else {
-            var primaryKeysSource = Object.keys(include.association.source.primaryKeys)
-              , tableSource       = tableName
-              , identSource       = include.association.identifier
-              , attrSource        = ((!include.association.source.hasPrimaryKeys || primaryKeysSource.length !== 1) ? 'id' : primaryKeysSource[0])
-
-            var primaryKeysTarget = Object.keys(include.association.target.primaryKeys)
-              , tableTarget       = include.as
-              , identTarget       = include.association.foreignIdentifier
-              , attrTarget        = ((!include.association.target.hasPrimaryKeys || primaryKeysTarget.length !== 1) ? 'id' : primaryKeysTarget[0])
-
-            var tableJunction     = include.association.connectorDAO.tableName
-            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(tableJunction) + " ON " + this.quoteIdentifier(tableSource) + "." + this.quoteIdentifier(attrSource) + " = " + this.quoteIdentifier(tableJunction) + "." + this.quoteIdentifier(identSource)
-            joinQuery += " LEFT OUTER JOIN " + this.quoteIdentifier(table) + " AS " + this.quoteIdentifier(as) + " ON " + this.quoteIdentifier(tableTarget) + "." + this.quoteIdentifier(attrTarget) + " = " + this.quoteIdentifier(tableJunction) + "." + this.quoteIdentifier(identTarget)
-          }
-
-        }.bind(this))
-
-        options.attributes = optAttributes.join(', ')
-      }
-
-      var query = "SELECT " + options.attributes + " FROM " + options.table
-      query += joinQuery
-
-      if (options.hasOwnProperty('where')) {
-        options.where = this.getWhereConditions(options.where, tableName, factory)
-        query += " WHERE " + options.where
-      }
-
-      if (options.group) {
-        options.group = Array.isArray(options.group) ? options.group.map(function (t) { return this.quote(t) }.bind(this)).join(', ') : options.group
-        query += " GROUP BY " + options.group
-      }
-
-      if (options.order) {
-        options.order = Array.isArray(options.order) ? options.order.map(function (t) { return this.quote(t) }.bind(this)).join(', ') : options.order
-        query += " ORDER BY " + options.order
-      }
-
-      if (options.offset && !options.limit) {
-        /*
-         * If no limit is defined, our best bet is to use the max number of rows in a table. From the SQLite docs:
-         * A 140 terabytes database can hold no more than approximately 1e+13 rows
-         */
-        query += " LIMIT " + options.offset + ", " + 10000000000000;
-      } else if (options.limit && !(options.include && (options.limit === 1))) {
-        if (options.offset) {
-          query += " LIMIT " + options.offset + ", " + options.limit
-        } else {
-          query += " LIMIT " + options.limit
-        }
-      }
-
-      query += ";"
-
-      return query
-    },
-
     updateQuery: function(tableName, attrValueHash, where, options) {
       attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull, options)
 
@@ -397,22 +320,6 @@ module.exports = (function() {
       return fields
     },
 
-    hashToWhereConditions: function(hash) {
-      for (var key in hash) {
-        if (hash.hasOwnProperty(key)) {
-          var value = hash[key]
-
-          if (typeof value === 'boolean') {
-            value = !!value ? 1 : 0
-          }
-
-          hash[key] = value
-        }
-      }
-
-      return hashToWhereConditions.call(this, hash).replace(/\\'/g, "''");
-    },
-
     showIndexQuery: function(tableName) {
       var sql = "PRAGMA INDEX_LIST('<%= tableName %>')"
       return Utils._.template(sql, { tableName: tableName })

test/associations/multiple-level-filters.test.js

+/* jshint camelcase: false, expr: true */
+var chai      = require('chai')
+  , expect    = chai.expect
+  , Support   = require(__dirname + '/../support')
+  , DataTypes = require(__dirname + "/../../lib/data-types")
+
+chai.Assertion.includeStack = true
+
+describe(Support.getTestDialectTeaser("Multiple Level Filters"), function() {
+  it('can filter through belongsTo', function(done) {
+    var User = this.sequelize.define('User', {username: DataTypes.STRING })
+      , Task = this.sequelize.define('Task', {title: DataTypes.STRING })
+      , Project = this.sequelize.define('Project', { title: DataTypes.STRING })
+
+    Project.belongsTo(User);
+    User.hasMany(Project)
+
+    Task.belongsTo(Project);
+    Project.hasMany(Task);
+
+
+    this.sequelize.sync({ force: true }).success(function() {
+      User.bulkCreate([{
+        username: 'leia'
+      }, {
+        username: 'vader'
+      }]).success(function() {
+        Project.bulkCreate([{
+          UserId: 1,
+          title: 'republic'
+        },{
+          title: 'empire'
+        }]).success(function() {
+          Task.bulkCreate([{
+            ProjectId: 1,
+            title: 'fight empire'
+          },{
+            ProjectId: 1,
+            title: 'stablish republic'
+          },{
+            ProjectId: 2,
+            title: 'destroy rebel alliance'
+          },{
+            ProjectId: 2,
+            title: 'rule everything'
+          }]).success(function() {
+            Task.findAll({
+              where: {
+                'project.user.username': 'leia'
+              }
+            }).success(function(tasks){
+              try{
+                expect(tasks.length).to.be.equal(2);
+                expect(tasks[0].title).to.be.equal('fight empire');
+                expect(tasks[1].title).to.be.equal('stablish republic');
+                done();
+              }catch(e){
+                done(e);
+              }
+            })
+          });
+        });
+      });
+    })
+  })
+
+  it('avoids duplicated tables in query', function(done) {
+    var User = this.sequelize.define('User', {username: DataTypes.STRING })
+      , Task = this.sequelize.define('Task', {title: DataTypes.STRING })
+      , Project = this.sequelize.define('Project', { title: DataTypes.STRING })
+
+    Project.belongsTo(User);
+    User.hasMany(Project)
+
+    Task.belongsTo(Project);
+    Project.hasMany(Task);
+
+
+    this.sequelize.sync({ force: true }).success(function() {
+      User.bulkCreate([{
+        username: 'leia'
+      }, {
+        username: 'vader'
+      }]).success(function() {
+        Project.bulkCreate([{
+          UserId: 1,
+          title: 'republic'
+        },{
+          UserId: 2,
+          title: 'empire'
+        }]).success(function() {
+          Task.bulkCreate([{
+            ProjectId: 1,
+            title: 'fight empire'
+          },{
+            ProjectId: 1,
+            title: 'stablish republic'
+          },{
+            ProjectId: 2,
+            title: 'destroy rebel alliance'
+          },{
+            ProjectId: 2,
+            title: 'rule everything'
+          }]).success(function() {
+            Task.findAll({
+              where: {
+                'project.user.username': 'leia',
+                'project.user.id': 1
+              }
+            }).success(function(tasks){
+              try{
+                expect(tasks.length).to.be.equal(2);
+                expect(tasks[0].title).to.be.equal('fight empire');
+                expect(tasks[1].title).to.be.equal('stablish republic');
+                done();
+              }catch(e){
+                done(e);
+              }
+            })
+          });
+        });
+      });
+    })
+  })
+
+  it('can filter through hasMany', function(done) {
+    var User = this.sequelize.define('User', {username: DataTypes.STRING })
+      , Task = this.sequelize.define('Task', {title: DataTypes.STRING })
+      , Project = this.sequelize.define('Project', { title: DataTypes.STRING })
+
+    Project.belongsTo(User);
+    User.hasMany(Project)
+
+    Task.belongsTo(Project);
+    Project.hasMany(Task);
+
+
+    this.sequelize.sync({ force: true }).success(function() {
+      User.bulkCreate([{
+        username: 'leia'
+      }, {
+        username: 'vader'
+      }]).success(function() {
+        Project.bulkCreate([{
+          UserId: 1,
+          title: 'republic'
+        },{
+          UserId: 2,
+          title: 'empire'
+        }]).success(function() {
+          Task.bulkCreate([{
+            ProjectId: 1,
+            title: 'fight empire'
+          },{
+            ProjectId: 1,
+            title: 'stablish republic'
+          },{
+            ProjectId: 2,
+            title: 'destroy rebel alliance'
+          },{
+            ProjectId: 2,
+            title: 'rule everything'
+          }]).success(function() {
+            User.findAll({
+              where: {
+                'projects.tasks.title': 'fight empire'
+              }
+            }).success(function(users){
+              try{
+                expect(users.length).to.be.equal(1);
+                expect(users[0].username).to.be.equal('leia');
+                done();
+              }catch(e){
+                done(e);
+              }
+            })
+          });
+        });
+      });
+    })
+  })
+
+  it('can filter through hasMany connector', function(done) {
+    var User = this.sequelize.define('User', {username: DataTypes.STRING })
+      , Project = this.sequelize.define('Project', { title: DataTypes.STRING })
+
+    Project.hasMany(User);
+    User.hasMany(Project)
+
+    this.sequelize.sync({ force: true }).success(function() {
+      User.bulkCreate([{
+        username: 'leia'
+      }, {
+        username: 'vader'
+      }]).success(function() {
+        Project.bulkCreate([{
+          title: 'republic'
+        },{
+          title: 'empire'
+        }]).success(function() {
+          User.find(1).success(function(user){
+            Project.find(1).success(function(project){
+              user.setProjects([project]).success(function(){
+
+                User.find(2).success(function(user){
+                  Project.find(2).success(function(project){
+                    user.setProjects([project]).success(function(){
+                      User.findAll({
+                        where: {
+                          'projects.title': 'republic'
+                        }
+                      }).success(function(users){
+                        try{
+                          expect(users.length).to.be.equal(1);
+                          expect(users[0].username).to.be.equal('leia');
+                          done();
+                        }catch(e){
+                          done(e);
+                        }
+                      })
+                    });
+                  });
+                });
+
+              });
+            });
+          });
+        });
+      });
+    })
+  })
+})