1 files changed, 19 insertions, 20 deletions

diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index 1d04e763f6..cb8f903474 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -1,12 +1,12 @@
 module ActiveRecord
   class PredicateBuilder # :nodoc:
     def self.build_from_hash(engine, attributes, default_table)
-      predicates = attributes.map do |column, value|
+      attributes.map do |column, value|
         table = default_table
 
         if value.is_a?(Hash)
           table = Arel::Table.new(column, engine)
-          build_from_hash(engine, value, table)
+          value.map { |k,v| build(table[k.to_sym], v) }
         else
           column = column.to_s
 
@@ -17,50 +17,49 @@ module ActiveRecord
 
           build(table[column.to_sym], value)
         end
-      end
-      predicates.flatten
+      end.flatten
     end
 
     def self.references(attributes)
-      references = attributes.map do |key, value|
+      attributes.map do |key, value|
         if value.is_a?(Hash)
           key
         else
           key = key.to_s
           key.split('.').first.to_sym if key.include?('.')
         end
-      end
-      references.compact
+      end.compact
     end
 
     private
       def self.build(attribute, value)
         case value
-        when ActiveRecord::Relation
-          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
-          attribute.in(value.arel.ast)
         when Array, ActiveRecord::Associations::CollectionProxy
           values = value.to_a.map {|x| x.is_a?(ActiveRecord::Model) ? x.id : x}
-          ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
+          ranges, values = values.partition {|v| v.is_a?(Range)}
 
-          array_predicates = ranges.map {|range| attribute.in(range)}
-
-          if values.include?(nil)
+          values_predicate = if values.include?(nil)
             values = values.compact
+
             case values.length
             when 0
-              array_predicates << attribute.eq(nil)
+              attribute.eq(nil)
             when 1
-              array_predicates << attribute.eq(values.first).or(attribute.eq(nil))
+              attribute.eq(values.first).or(attribute.eq(nil))
             else
-              array_predicates << attribute.in(values).or(attribute.eq(nil))
+              attribute.in(values).or(attribute.eq(nil))
             end
           else
-            array_predicates << attribute.in(values)
+            attribute.in(values)
           end
 
-          array_predicates.inject {|composite, predicate| composite.or(predicate)}
-        when Range, Arel::Relation
+          array_predicates = ranges.map { |range| attribute.in(range) }
+          array_predicates << values_predicate
+          array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        when ActiveRecord::Relation
+          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+          attribute.in(value.arel.ast)
+        when Range
           attribute.in(value)
         when ActiveRecord::Model
           attribute.eq(value.id)