activerecord 4.1.16 → 4.2.0.beta1

data/lib/active_record/relation.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+require 'arel/collectors/bind'
 
 module ActiveRecord
   # = Active Record Relation
@@ -11,6 +12,7 @@ module ActiveRecord
 
     SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering,
                             :reverse_order, :distinct, :create_with, :uniq]
+    INVALID_METHODS_FOR_DELETE_ALL = [:limit, :distinct, :offset, :group, :having]
 
     VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
 
@@ -230,6 +232,7 @@ module ActiveRecord
     # Please see further details in the
     # {Active Record Query Interface guide}[http://guides.rubyonrails.org/active_record_querying.html#running-explain].
     def explain
+      #TODO: Fix for binds.
       exec_explain(collecting_queries_for_explain { exec_queries })
     end
 
@@ -239,6 +242,11 @@ module ActiveRecord
       @records
     end
 
+    # Serializes the relation objects Array.
+    def encode_with(coder)
+      coder.represent_seq(nil, to_a)
+    end
+
     def as_json(options = nil) #:nodoc:
       to_a.as_json(options)
     end
@@ -330,7 +338,8 @@ module ActiveRecord
         stmt.wheres = arel.constraints
       end
 
-      @klass.connection.update stmt, 'SQL', bind_values
+      bvs = bind_values + arel.bind_values
+      @klass.connection.update stmt, 'SQL', bvs
     end
 
     # Updates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -434,12 +443,21 @@ module ActiveRecord
     # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the +destroy_all+ method instead.
     #
-    # If a limit scope is supplied, +delete_all+ raises an ActiveRecord error:
+    # If an invalid method is supplied, +delete_all+ raises an ActiveRecord error:
     #
     #   Post.limit(100).delete_all
-    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit scope
+    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit
     def delete_all(conditions = nil)
-      raise ActiveRecordError.new("delete_all doesn't support limit scope") if self.limit_value
+      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select { |method|
+        if MULTI_VALUE_METHODS.include?(method)
+          send("#{method}_values").any?
+        else
+          send("#{method}_value")
+        end
+      }
+      if invalid_methods.any?
+        raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
+      end
 
       if conditions
         where(conditions).delete_all
@@ -523,11 +541,11 @@ module ActiveRecord
                       find_with_associations { |rel| relation = rel }
                     end
 
-                    ast   = relation.arel.ast
-                    binds = relation.bind_values.dup
-                    visitor.accept(ast) do
-                      connection.quote(*binds.shift.reverse)
-                    end
+                    arel  = relation.arel
+                    binds = (arel.bind_values + relation.bind_values).dup
+                    binds.map! { |bv| connection.quote(*bv.reverse) }
+                    collect = visitor.accept(arel.ast, Arel::Collectors::Bind.new)
+                    collect.substitute_binds(binds).join
                   end
     end
 
@@ -544,7 +562,13 @@ module ActiveRecord
 
       Hash[equalities.map { |where|
         name = where.left.name
-        [name, binds.fetch(name.to_s) { where.right }]
+        [name, binds.fetch(name.to_s) {
+          case where.right
+          when Array then where.right.map(&:val)
+          else
+            where.right.val
+          end
+        }]
       }]
     end
 
@@ -608,7 +632,7 @@ module ActiveRecord
     private
 
     def exec_queries
-      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, bind_values)
+      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, arel.bind_values + bind_values)
 
       preload = preload_values
       preload +=  includes_values unless eager_loading?

data/lib/active_record/relation/batches.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   module Batches
     # Looping through a collection of records from the database
@@ -115,7 +114,6 @@ module ActiveRecord
       end
 
       relation = relation.reorder(batch_order).limit(batch_size)
-      relation.reverse_order_value = false
       records = start ? relation.where(table[primary_key].gteq(start)).to_a : relation.to_a
 
       while records.any?

data/lib/active_record/relation/calculations.rb

@@ -19,14 +19,22 @@ 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 = {})
       # TODO: Remove options argument as soon we remove support to
       # activerecord-deprecated_finders.
@@ -170,21 +178,7 @@ module ActiveRecord
           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.cast_values(klass.column_types)
       end
     end
 
@@ -246,11 +240,14 @@ 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)
 
@@ -260,13 +257,14 @@ module ActiveRecord
         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)
@@ -277,7 +275,7 @@ module ActiveRecord
 
       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
+        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
@@ -329,14 +327,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 +361,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 +390,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/delegation.rb

@@ -40,7 +40,7 @@ module ActiveRecord
     BLACKLISTED_ARRAY_METHODS = [
       :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
       :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
-      :keep_if, :pop, :shift, :delete_at, :select!
+      :keep_if, :pop, :shift, :delete_at, :compact, :select!
     ].to_set # :nodoc:
 
     delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join, to: :to_a

data/lib/active_record/relation/finder_methods.rb

@@ -1,3 +1,5 @@
+require 'active_support/deprecation'
+
 module ActiveRecord
   module FinderMethods
     ONE_AS_ONE = '1 AS one'
@@ -127,9 +129,9 @@ module ActiveRecord
     #
     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
 
@@ -179,7 +181,7 @@ 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
@@ -195,7 +197,7 @@ 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
@@ -211,7 +213,7 @@ 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
@@ -227,7 +229,7 @@ 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
@@ -243,7 +245,7 @@ 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
@@ -280,7 +282,12 @@ 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 "You are passing an instance of ActiveRecord::Base to `exists?`." \
+          "Please pass the id of the object by calling `.id`"
+      end
+
       return false if !conditions
 
       relation = apply_join_dependency(self, construct_join_dependency)
@@ -292,10 +299,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 = 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 +331,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 +357,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
@@ -358,7 +372,7 @@ module ActiveRecord
     def construct_relation_for_association_calculations
       from = arel.froms.first
       if Arel::Table === from
-        apply_join_dependency(self, construct_join_dependency(joins_values))
+        apply_join_dependency(self, construct_join_dependency)
       else
         # FIXME: as far as I can tell, `from` will always be an Arel::Table.
         # There are no tests that test this branch, but presumably it's
@@ -418,7 +432,11 @@ module ActiveRecord
     end
 
     def find_one(id)
-      id = id.id if ActiveRecord::Base === id
+      if ActiveRecord::Base === id
+        id = id.id
+        ActiveSupport::Deprecation.warn "You are passing an instance of ActiveRecord::Base to `find`." \
+          "Please pass the id of the object by calling `.id`"
+      end
 
       column = columns_hash[primary_key]
       substitute = connection.substitute_at(column, bind_values.length)
@@ -461,20 +479,24 @@ 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_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

@@ -147,7 +147,6 @@ module ActiveRecord
       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]
 
         unless values[:create_with].blank?
           relation.create_with_value = (relation.create_with_value || {}).merge(values[:create_with])

data/lib/active_record/relation/predicate_builder.rb

@@ -56,17 +56,11 @@ module ActiveRecord
       # For polymorphic relationships, find the foreign key and type:
       # PriceEstimate.where(estimate_of: treasure)
       if klass && reflection = klass._reflect_on_association(column.to_sym)
-        base_class = polymorphic_base_class_from_value(value)
-        if reflection.polymorphic? && base_class
+        if reflection.polymorphic? && base_class = polymorphic_base_class_from_value(value)
           queries << build(table[reflection.foreign_type], base_class)
         end
 
         column = reflection.foreign_key
-
-        if base_class
-          primary_key = reflection.association_primary_key(base_class)
-          value = convert_value_to_association_ids(value, primary_key)
-        end
       end
 
       queries << build(table[column], value)
@@ -119,8 +113,6 @@ module ActiveRecord
     register_handler(Relation, RelationHandler.new)
     register_handler(Array, ArrayHandler.new)
 
-    private
-
     def self.build(attribute, value)
       handler_for(value).call(attribute, value)
     end
@@ -130,18 +122,5 @@ module ActiveRecord
       @handlers.detect { |klass, _| klass === object }.last
     end
     private_class_method :handler_for
-
-    def self.convert_value_to_association_ids(value, primary_key)
-      case value
-      when Relation
-        value.select(primary_key)
-      when Array
-        value.map { |v| convert_value_to_association_ids(v, primary_key) }
-      when Base
-        value.read_attribute(primary_key)
-      else
-        value
-      end
-    end
   end
 end