activerecord 4.1.16 → 4.2.11.3

data/lib/active_record/relation/calculations.rb

@@ -20,17 +20,31 @@ module ActiveRecord
     #   Person.group(:city).count
     #   # => { 'Rome' => 5, 'Paris' => 3 }
     #
+    # If +count+ is used with +group+ for multiple columns, it returns a Hash whose
+    # keys are an array containing the individual values of each column and the value
+    # of each key would be the +count+.
+    #
+    #   Article.group(:status, :category).count
+    #   # =>  {["draft", "business"]=>10, ["draft", "technology"]=>4,
+    #          ["published", "business"]=>0, ["published", "technology"]=>2}
+    #
     # If +count+ is used with +select+, it will count the selected columns:
     #
     #   Person.select(:age).count
     #   # => counts the number of different age values
     #
     # Note: not all valid +select+ expressions are valid +count+ expressions. The specifics differ
-    # between databases. In invalid cases, an error from the databsae is thrown.
+    # between databases. In invalid cases, an error from the database is thrown.
     def count(column_name = nil, options = {})
+      if options.present? && !ActiveRecord.const_defined?(:DeprecatedFinders)
+        raise ArgumentError, "Relation#count does not support finder options anymore. " \
+                             "Please build a scope and then call count on it or use the " \
+                             "activerecord-deprecated_finders gem to enable this functionality."
+
+      end
+
       # TODO: Remove options argument as soon we remove support to
       # activerecord-deprecated_finders.
-      column_name, options = nil, column_name if column_name.is_a?(Hash)
       calculate(:count, column_name, options)
     end
 
@@ -80,7 +94,7 @@ module ActiveRecord
     #
     # There are two basic forms of output:
     #
-    #   * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float
+    #   * Single aggregate value: The single value is type cast to Integer for COUNT, Float
     #     for AVG, and the given column's type for everything else.
     #
     #   * Grouped values: This returns an ordered hash of the values and groups them. It
@@ -169,22 +183,8 @@ module ActiveRecord
         relation.select_values = column_names.map { |cn|
           columns_hash.key?(cn) ? arel_table[cn] : cn
         }
-        result = klass.connection.select_all(relation.arel, nil, bind_values)
-        columns = result.columns.map do |key|
-          klass.column_types.fetch(key) {
-            result.column_types.fetch(key) { result.identity_type }
-          }
-        end
-
-        result = result.rows.map do |values|
-          values = result.columns.zip(values).map do |column_name, value|
-            single_attr_hash = { column_name => value }
-            klass.initialize_attributes(single_attr_hash).values.first
-          end
-
-          columns.zip(values).map { |column, value| column.type_cast value }
-        end
-        columns.one? ? result.map!(&:first) : result
+        result = klass.connection.select_all(relation.arel, nil, relation.arel.bind_values + bind_values)
+        result.cast_values(klass.column_types)
       end
     end
 
@@ -246,27 +246,32 @@ module ActiveRecord
 
       column_alias = column_name
 
+      bind_values = nil
+
       if operation == "count" && (relation.limit_value || relation.offset_value)
         # Shortcut when limit is zero.
         return 0 if relation.limit_value == 0
 
         query_builder = build_count_subquery(relation, column_name, distinct)
+        bind_values = query_builder.bind_values + relation.bind_values
       else
         column = aggregate_column(column_name)
 
         select_value = operation_over_aggregate_column(column, operation, distinct)
 
         column_alias = select_value.alias
+        column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
         relation.select_values = [select_value]
 
         query_builder = relation.arel
+        bind_values = query_builder.bind_values + relation.bind_values
       end
 
-      result = @klass.connection.select_all(query_builder, nil, relation.bind_values)
+      result = @klass.connection.select_all(query_builder, nil, bind_values)
       row    = result.first
       value  = row && row.values.first
       column = result.column_types.fetch(column_alias) do
-        column_for(column_name)
+        type_for(column_name)
       end
 
       type_cast_calculated_value(value, column, operation)
@@ -276,12 +281,13 @@ module ActiveRecord
       group_attrs = group_values
 
       if group_attrs.first.respond_to?(:to_sym)
-        association  = @klass._reflect_on_association(group_attrs.first.to_sym)
-        associated   = group_attrs.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
+        association  = @klass._reflect_on_association(group_attrs.first)
+        associated   = group_attrs.size == 1 && association && association.belongs_to? # only count belongs_to associations
         group_fields = Array(associated ? association.foreign_key : group_attrs)
       else
         group_fields = group_attrs
       end
+      group_fields = arel_columns(group_fields)
 
       group_aliases = group_fields.map { |field|
         column_alias_for(field)
@@ -304,7 +310,7 @@ module ActiveRecord
           operation,
           distinct).as(aggregate_alias)
       ]
-      select_values += select_values unless having_values.empty?
+      select_values += self.select_values unless having_values.empty?
 
       select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
         if field.respond_to?(:as)
@@ -318,7 +324,7 @@ module ActiveRecord
       relation.group_values  = group
       relation.select_values = select_values
 
-      calculated_data = @klass.connection.select_all(relation, nil, bind_values)
+      calculated_data = @klass.connection.select_all(relation, nil, relation.arel.bind_values + bind_values)
 
       if association
         key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
@@ -329,14 +335,14 @@ module ActiveRecord
       Hash[calculated_data.map do |row|
         key = group_columns.map { |aliaz, col_name|
           column = calculated_data.column_types.fetch(aliaz) do
-            column_for(col_name)
+            type_for(col_name)
           end
           type_cast_calculated_value(row[aliaz], column)
         }
         key = key.first if key.size == 1
         key = key_records[key] if associated
 
-        column_type = calculated_data.column_types.fetch(aggregate_alias) { column_for(column_name) }
+        column_type = calculated_data.column_types.fetch(aggregate_alias) { type_for(column_name) }
         [key, type_cast_calculated_value(row[aggregate_alias], column_type, operation)]
       end]
     end
@@ -363,24 +369,20 @@ module ActiveRecord
       @klass.connection.table_alias_for(table_name)
     end
 
-    def column_for(field)
+    def type_for(field)
       field_name = field.respond_to?(:name) ? field.name.to_s : field.to_s.split('.').last
-      @klass.columns_hash[field_name]
+      @klass.type_for_attribute(field_name)
     end
 
-    def type_cast_calculated_value(value, column, operation = nil)
+    def type_cast_calculated_value(value, type, operation = nil)
       case operation
         when 'count'   then value.to_i
-        when 'sum'     then type_cast_using_column(value || 0, column)
+        when 'sum'     then type.type_cast_from_database(value || 0)
         when 'average' then value.respond_to?(:to_d) ? value.to_d : value
-        else type_cast_using_column(value, column)
+        else type.type_cast_from_database(value)
       end
     end
 
-    def type_cast_using_column(value, column)
-      column ? column.type_cast(value) : value
-    end
-
     # TODO: refactor to allow non-string `select_values` (eg. Arel nodes).
     def select_for_count
       if select_values.present?
@@ -396,9 +398,11 @@ module ActiveRecord
 
       aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
       relation.select_values = [aliased_column]
-      subquery = relation.arel.as(subquery_alias)
+      arel = relation.arel
+      subquery = arel.as(subquery_alias)
 
       sm = Arel::SelectManager.new relation.engine
+      sm.bind_values = arel.bind_values
       select_value = operation_over_aggregate_column(column_alias, 'count', distinct)
       sm.project(select_value).from(subquery)
     end

data/lib/active_record/relation/finder_methods.rb

@@ -1,3 +1,6 @@
+require 'active_support/deprecation'
+require 'active_support/core_ext/string/filters'
+
 module ActiveRecord
   module FinderMethods
     ONE_AS_ONE = '1 AS one'
@@ -79,12 +82,16 @@ module ActiveRecord
     #   Post.find_by "published_at < ?", 2.weeks.ago
     def find_by(*args)
       where(*args).take
+    rescue RangeError
+      nil
     end
 
     # Like <tt>find_by</tt>, except that if no record is found, raises
     # an <tt>ActiveRecord::RecordNotFound</tt> error.
     def find_by!(*args)
       where(*args).take!
+    rescue RangeError
+      raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range value"
     end
 
     # Gives a record (or N records if a parameter is supplied) without any implied
@@ -101,42 +108,30 @@ module ActiveRecord
     # Same as +take+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
     # is found. Note that <tt>take!</tt> accepts no arguments.
     def take!
-      take or raise RecordNotFound
+      take or raise RecordNotFound.new("Couldn't find #{@klass.name} with [#{arel.where_sql}]")
     end
 
     # Find the first record (or first N records if a parameter is supplied).
     # If no order is defined it will order by primary key.
     #
-    #   Person.first # returns the first object fetched by SELECT * FROM people
+    #   Person.first # returns the first object fetched by SELECT * FROM people ORDER BY people.id LIMIT 1
     #   Person.where(["user_name = ?", user_name]).first
     #   Person.where(["user_name = :u", { u: user_name }]).first
     #   Person.order("created_on DESC").offset(5).first
-    #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people LIMIT 3
-    #
-    # ==== Rails 3
-    #
-    #   Person.first # SELECT "people".* FROM "people" LIMIT 1
-    #
-    # NOTE: Rails 3 may not order this query by the primary key and the order
-    # will depend on the database implementation. In order to ensure that behavior,
-    # use <tt>User.order(:id).first</tt> instead.
-    #
-    # ==== Rails 4
-    #
-    #   Person.first # SELECT "people".* FROM "people" ORDER BY "people"."id" ASC LIMIT 1
+    #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people ORDER BY people.id LIMIT 3
     #
     def first(limit = nil)
       if limit
-        find_nth_with_limit(offset_value, limit)
+        find_nth_with_limit(offset_index, limit)
       else
-        find_nth(:first, offset_value)
+        find_nth(0, offset_index)
       end
     end
 
     # Same as +first+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
     # is found. Note that <tt>first!</tt> accepts no arguments.
     def first!
-      first or raise RecordNotFound
+      find_nth! 0
     end
 
     # Find the last record (or last N records if a parameter is supplied).
@@ -169,7 +164,7 @@ module ActiveRecord
     # Same as +last+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
     # is found. Note that <tt>last!</tt> accepts no arguments.
     def last!
-      last or raise RecordNotFound
+      last or raise RecordNotFound.new("Couldn't find #{@klass.name} with [#{arel.where_sql}]")
     end
 
     # Find the second record.
@@ -179,13 +174,13 @@ module ActiveRecord
     #   Person.offset(3).second # returns the second object from OFFSET 3 (which is OFFSET 4)
     #   Person.where(["user_name = :u", { u: user_name }]).second
     def second
-      find_nth(:second, offset_value ? offset_value + 1 : 1)
+      find_nth(1, offset_index)
     end
 
     # Same as +second+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
     # is found.
     def second!
-      second or raise RecordNotFound
+      find_nth! 1
     end
 
     # Find the third record.
@@ -195,13 +190,13 @@ module ActiveRecord
     #   Person.offset(3).third # returns the third object from OFFSET 3 (which is OFFSET 5)
     #   Person.where(["user_name = :u", { u: user_name }]).third
     def third
-      find_nth(:third, offset_value ? offset_value + 2 : 2)
+      find_nth(2, offset_index)
     end
 
     # Same as +third+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
     # is found.
     def third!
-      third or raise RecordNotFound
+      find_nth! 2
     end
 
     # Find the fourth record.
@@ -211,13 +206,13 @@ module ActiveRecord
     #   Person.offset(3).fourth # returns the fourth object from OFFSET 3 (which is OFFSET 6)
     #   Person.where(["user_name = :u", { u: user_name }]).fourth
     def fourth
-      find_nth(:fourth, offset_value ? offset_value + 3 : 3)
+      find_nth(3, offset_index)
     end
 
     # Same as +fourth+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
     # is found.
     def fourth!
-      fourth or raise RecordNotFound
+      find_nth! 3
     end
 
     # Find the fifth record.
@@ -227,13 +222,13 @@ module ActiveRecord
     #   Person.offset(3).fifth # returns the fifth object from OFFSET 3 (which is OFFSET 7)
     #   Person.where(["user_name = :u", { u: user_name }]).fifth
     def fifth
-      find_nth(:fifth, offset_value ? offset_value + 4 : 4)
+      find_nth(4, offset_index)
     end
 
     # Same as +fifth+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
     # is found.
     def fifth!
-      fifth or raise RecordNotFound
+      find_nth! 4
     end
 
     # Find the forty-second record. Also known as accessing "the reddit".
@@ -243,13 +238,13 @@ module ActiveRecord
     #   Person.offset(3).forty_two # returns the forty-second object from OFFSET 3 (which is OFFSET 44)
     #   Person.where(["user_name = :u", { u: user_name }]).forty_two
     def forty_two
-      find_nth(:forty_two, offset_value ? offset_value + 41 : 41)
+      find_nth(41, offset_index)
     end
 
     # Same as +forty_two+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
     # is found.
     def forty_two!
-      forty_two or raise RecordNotFound
+      find_nth! 41
     end
 
     # Returns +true+ if a record exists in the table that matches the +id+ or
@@ -280,7 +275,14 @@ module ActiveRecord
     #   Person.exists?(false)
     #   Person.exists?
     def exists?(conditions = :none)
-      conditions = conditions.id if Base === conditions
+      if Base === conditions
+        conditions = conditions.id
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          You are passing an instance of ActiveRecord::Base to `exists?`.
+          Please pass the id of the object by calling `.id`
+        MSG
+      end
+
       return false if !conditions
 
       relation = apply_join_dependency(self, construct_join_dependency)
@@ -292,10 +294,12 @@ module ActiveRecord
       when Array, Hash
         relation = relation.where(conditions)
       else
-        relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
+        unless conditions == :none
+          relation = relation.where(primary_key => conditions)
+        end
       end
 
-      connection.select_value(relation, "#{name} Exists", relation.bind_values) ? true : false
+      connection.select_value(relation, "#{name} Exists", relation.arel.bind_values + relation.bind_values) ? true : false
     end
 
     # This method is called whenever no records are found with either a single
@@ -322,6 +326,10 @@ module ActiveRecord
 
     private
 
+    def offset_index
+      offset_value || 0
+    end
+
     def find_with_associations
       # NOTE: the JoinDependency constructed here needs to know about
       #       any joins already present in `self`, so pass them in
@@ -344,7 +352,8 @@ module ActiveRecord
         if ActiveRecord::NullRelation === relation
           []
         else
-          rows = connection.select_all(relation.arel, 'SQL', relation.bind_values.dup)
+          arel = relation.arel
+          rows = connection.select_all(arel, 'SQL', arel.bind_values + relation.bind_values)
           join_dependency.instantiate(rows, aliases)
         end
       end
@@ -387,8 +396,9 @@ module ActiveRecord
         "#{quoted_table_name}.#{quoted_primary_key}", relation.order_values)
 
       relation = relation.except(:select).select(values).distinct!
+      arel = relation.arel
 
-      id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
+      id_rows = @klass.connection.select_all(arel, 'SQL', arel.bind_values + relation.bind_values)
       id_rows.map {|row| row[primary_key]}
     end
 
@@ -415,15 +425,20 @@ module ActiveRecord
       else
         find_some(ids)
       end
+    rescue RangeError
+      raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range ID"
     end
 
     def find_one(id)
-      id = id.id if ActiveRecord::Base === id
+      if ActiveRecord::Base === id
+        id = id.id
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          You are passing an instance of ActiveRecord::Base to `find`.
+          Please pass the id of the object by calling `.id`
+        MSG
+      end
 
-      column = columns_hash[primary_key]
-      substitute = connection.substitute_at(column, bind_values.length)
-      relation = where(table[primary_key].eq(substitute))
-      relation.bind_values += [[column, id]]
+      relation = where(primary_key => id)
       record = relation.take
 
       raise_record_not_found_exception!(id, 0, 1) unless record
@@ -432,7 +447,7 @@ module ActiveRecord
     end
 
     def find_some(ids)
-      result = where(table[primary_key].in(ids)).to_a
+      result = where(primary_key => ids).to_a
 
       expected_size =
         if limit_value && ids.size > limit_value
@@ -461,20 +476,28 @@ module ActiveRecord
       end
     end
 
-    def find_nth(ordinal, offset)
+    def find_nth(index, offset)
       if loaded?
-        @records.send(ordinal)
+        @records[index]
       else
+        offset += index
         @offsets[offset] ||= find_nth_with_limit(offset, 1).first
       end
     end
 
+    def find_nth!(index)
+      find_nth(index, offset_index) or raise RecordNotFound.new("Couldn't find #{@klass.name} with [#{arel.where_sql}]")
+    end
+
     def find_nth_with_limit(offset, limit)
-      if order_values.empty? && primary_key
-        order(arel_table[primary_key].asc).limit(limit).offset(offset).to_a
-      else
-        limit(limit).offset(offset).to_a
-      end
+      relation = if order_values.empty? && primary_key
+                   order(arel_table[primary_key].asc)
+                 else
+                   self
+                 end
+
+      relation = relation.offset(offset) unless offset.zero?
+      relation.limit(limit).to_a
     end
 
     def find_last

data/lib/active_record/relation/merger.rb

@@ -13,7 +13,7 @@ module ActiveRecord
         @hash     = hash
       end
 
-      def merge
+      def merge #:nodoc:
         Merger.new(relation, other).merge
       end
 
@@ -51,7 +51,8 @@ module ActiveRecord
 
       NORMAL_VALUES = Relation::SINGLE_VALUE_METHODS +
                       Relation::MULTI_VALUE_METHODS -
-                      [:joins, :where, :order, :bind, :reverse_order, :lock, :create_with, :reordering, :from] # :nodoc:
+                      [:includes, :preload, :joins, :where, :order, :bind, :reverse_order, :lock, :create_with, :reordering, :from] # :nodoc:
+
 
       def normal_values
         NORMAL_VALUES
@@ -75,6 +76,7 @@ module ActiveRecord
 
         merge_multi_values
         merge_single_values
+        merge_preloads
         merge_joins
 
         relation
@@ -82,13 +84,34 @@ module ActiveRecord
 
       private
 
+      def merge_preloads
+        return if other.preload_values.empty? && other.includes_values.empty?
+
+        if other.klass == relation.klass
+          relation.preload!(*other.preload_values) unless other.preload_values.empty?
+          relation.includes!(other.includes_values) unless other.includes_values.empty?
+        else
+          reflection = relation.klass.reflect_on_all_associations.find do |r|
+            r.class_name == other.klass.name
+          end || return
+
+          unless other.preload_values.empty?
+            relation.preload! reflection.name => other.preload_values
+          end
+
+          unless other.includes_values.empty?
+            relation.includes! reflection.name => other.includes_values
+          end
+        end
+      end
+
       def merge_joins
-        return if values[:joins].blank?
+        return if other.joins_values.blank?
 
         if other.klass == relation.klass
-          relation.joins!(*values[:joins])
+          relation.joins!(*other.joins_values)
         else
-          joins_dependency, rest = values[:joins].partition do |join|
+          joins_dependency, rest = other.joins_values.partition do |join|
             case join
             when Hash, Symbol, Array
               true
@@ -108,49 +131,36 @@ module ActiveRecord
 
       def merge_multi_values
         lhs_wheres = relation.where_values
-        rhs_wheres = values[:where] || []
+        rhs_wheres = other.where_values
 
         lhs_binds  = relation.bind_values
-        rhs_binds  = values[:bind] || []
+        rhs_binds  = other.bind_values
 
         removed, kept = partition_overwrites(lhs_wheres, rhs_wheres)
 
         where_values = kept + rhs_wheres
         bind_values  = filter_binds(lhs_binds, removed) + rhs_binds
 
-        conn = relation.klass.connection
-        bv_index = 0
-        where_values.map! do |node|
-          if Arel::Nodes::Equality === node && Arel::Nodes::BindParam === node.right
-            substitute = conn.substitute_at(bind_values[bv_index].first, bv_index)
-            bv_index += 1
-            Arel::Nodes::Equality.new(node.left, substitute)
-          else
-            node
-          end
-        end
-
         relation.where_values = where_values
         relation.bind_values  = bind_values
 
-        if values[:reordering]
+        if other.reordering_value
           # override any order specified in the original relation
-          relation.reorder! values[:order]
-        elsif values[:order]
+          relation.reorder! other.order_values
+        elsif other.order_values
           # merge in order_values from relation
-          relation.order! values[:order]
+          relation.order! other.order_values
         end
 
-        relation.extend(*values[:extending]) unless values[:extending].blank?
+        relation.extend(*other.extending_values) unless other.extending_values.blank?
       end
 
       def merge_single_values
-        relation.from_value          = values[:from] unless relation.from_value
-        relation.lock_value          = values[:lock] unless relation.lock_value
-        relation.reverse_order_value = values[:reverse_order]
+        relation.from_value          = other.from_value unless relation.from_value
+        relation.lock_value          = other.lock_value unless relation.lock_value
 
-        unless values[:create_with].blank?
-          relation.create_with_value = (relation.create_with_value || {}).merge(values[:create_with])
+        unless other.create_with_value.blank?
+          relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
         end
       end
 

data/lib/active_record/relation/predicate_builder/array_handler.rb

@@ -1,29 +1,48 @@
+require 'active_support/core_ext/string/filters'
+
 module ActiveRecord
   class PredicateBuilder
     class ArrayHandler # :nodoc:
       def call(attribute, value)
         values = value.map { |x| x.is_a?(Base) ? x.id : x }
-        ranges, values = values.partition { |v| v.is_a?(Range) }
+        nils, values = values.partition(&:nil?)
+
+        if values.any? { |val| val.is_a?(Array) }
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing a nested array to Active Record finder methods is
+            deprecated and will be removed. Flatten your array before using
+            it for 'IN' conditions.
+          MSG
 
-        values_predicate = if values.include?(nil)
-          values = values.compact
+          flat_values = values.flatten
+          values = flat_values unless flat_values.include?(nil)
+        end
+
+        return attribute.in([]) if values.empty? && nils.empty?
 
+        ranges, values = values.partition { |v| v.is_a?(Range) }
+
+        values_predicate =
           case values.length
-          when 0
-            attribute.eq(nil)
-          when 1
-            attribute.eq(values.first).or(attribute.eq(nil))
-          else
-            attribute.in(values).or(attribute.eq(nil))
+          when 0 then NullPredicate
+          when 1 then attribute.eq(values.first)
+          else attribute.in(values)
           end
-        else
-          attribute.in(values)
+
+        unless nils.empty?
+          values_predicate = values_predicate.or(attribute.eq(nil))
         end
 
-        array_predicates = ranges.map { |range| attribute.in(range) }
-        array_predicates << values_predicate
+        array_predicates = ranges.map { |range| attribute.between(range) }
+        array_predicates.unshift(values_predicate)
         array_predicates.inject { |composite, predicate| composite.or(predicate) }
       end
+
+      module NullPredicate # :nodoc:
+        def self.or(other)
+          other
+        end
+      end
     end
   end
 end

data/lib/active_record/relation/predicate_builder/relation_handler.rb

@@ -6,11 +6,7 @@ module ActiveRecord
           value = value.select(value.klass.arel_table[value.klass.primary_key])
         end
 
-        value = value.dup
-        value.where_values = value.where_values.map do |node|
-          node.dup rescue node
-        end
-        attribute.in(value.arel.ast)
+        attribute.in(value.arel)
       end
     end
   end