activerecord 3.0.1 → 3.0.2

data/lib/active_record/relation/batches.rb

@@ -50,7 +50,7 @@ module ActiveRecord
     def find_in_batches(options = {})
       relation = self
 
-      if orders.present? || taken.present?
+      unless arel.orders.blank? && arel.taken.blank?
         ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
       end
 

data/lib/active_record/relation/calculations.rb

@@ -14,9 +14,9 @@ module ActiveRecord
     #
     # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ].
     #   See conditions in the intro to ActiveRecord::Base.
-    # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" 
+    # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id"
     #   (rarely needed) or named associations in the same form used for the <tt>:include</tt> option, which will
-    #   perform an INNER JOIN on the associated table(s). If the value is a string, then the records 
+    #   perform an INNER JOIN on the associated table(s). If the value is a string, then the records
     #   will be returned read-only since they will have attributes that do not correspond to the table's columns.
     #   Pass <tt>:readonly => false</tt> to override.
     # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs.
@@ -175,28 +175,39 @@ module ActiveRecord
       end
 
       distinct = options[:distinct] || distinct
-      column_name = :all if column_name.blank? && operation == "count"
 
       if @group_values.any?
-        return execute_grouped_calculation(operation, column_name)
+        execute_grouped_calculation(operation, column_name, distinct)
       else
-        return execute_simple_calculation(operation, column_name, distinct)
+        execute_simple_calculation(operation, column_name, distinct)
       end
     end
 
-    def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-      column = if @klass.column_names.include?(column_name.to_s)
-        Arel::Attribute.new(@klass.unscoped, column_name)
+    def aggregate_column(column_name)
+      if @klass.column_names.include?(column_name.to_s)
+        Arel::Attribute.new(@klass.unscoped.table, column_name)
       else
-        Arel::SqlLiteral.new(column_name == :all ? "*" : column_name.to_s)
+        Arel.sql(column_name == :all ? "*" : column_name.to_s)
       end
+    end
+
+    def operation_over_aggregate_column(column, operation, distinct)
+      operation == 'count' ? column.count(distinct) : column.send(operation)
+    end
+
+    def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+      column = aggregate_column(column_name)
 
       # Postgresql doesn't like ORDER BY when there are no GROUP BY
-      relation = except(:order).select(operation == 'count' ? column.count(distinct) : column.send(operation))
+      relation = except(:order)
+      select_value = operation_over_aggregate_column(column, operation, distinct)
+
+      relation.select_values = [select_value]
+
       type_cast_calculated_value(@klass.connection.select_value(relation.to_sql), column_for(column_name), operation)
     end
 
-    def execute_grouped_calculation(operation, column_name) #:nodoc:
+    def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
       group_attr      = @group_values.first
       association     = @klass.reflect_on_association(group_attr.to_sym)
       associated      = association && association.macro == :belongs_to # only count belongs_to associations
@@ -206,33 +217,31 @@ module ActiveRecord
 
       group = @klass.connection.adapter_name == 'FrontBase' ? group_alias : group_field
 
-      aggregate_alias = column_alias_for(operation, column_name)
-
-      select_statement = if operation == 'count' && column_name == :all
-        "COUNT(*) AS count_all"
+      if operation == 'count' && column_name == :all
+        aggregate_alias = 'count_all'
       else
-        Arel::Attribute.new(@klass.unscoped, column_name).send(operation).as(aggregate_alias).to_sql
+        aggregate_alias = column_alias_for(operation, column_name)
       end
 
-      select_statement <<  ", #{group_field} AS #{group_alias}"
-
-      relation = except(:group).select(select_statement).group(group)
+      relation = except(:group).group(group)
+      relation.select_values = [
+        operation_over_aggregate_column(aggregate_column(column_name), operation, distinct).as(aggregate_alias),
+        "#{group_field} AS #{group_alias}"
+      ]
 
       calculated_data = @klass.connection.select_all(relation.to_sql)
 
       if association
         key_ids     = calculated_data.collect { |row| row[group_alias] }
         key_records = association.klass.base_class.find(key_ids)
-        key_records = key_records.inject({}) { |hsh, r| hsh.merge(r.id => r) }
+        key_records = Hash[key_records.map { |r| [r.id, r] }]
       end
 
-      calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
-        key   = type_cast_calculated_value(row[group_alias], group_column)
-        key   = key_records[key] if associated
-        value = row[aggregate_alias]
-        all[key] = type_cast_calculated_value(value, column_for(column_name), operation)
-        all
-      end
+      ActiveSupport::OrderedHash[calculated_data.map do |row|
+        key = type_cast_calculated_value(row[group_alias], group_column)
+        key = key_records[key] if associated
+        [key, type_cast_calculated_value(row[aggregate_alias], column_for(column_name), operation)]
+      end]
     end
 
     # Converts the given keys to the value that the database adapter returns as
@@ -268,7 +277,7 @@ module ActiveRecord
           else type_cast_using_column(value, column)
         end
       else
-        value
+        type_cast_using_column(value, column)
       end
     end
 

data/lib/active_record/relation/finder_methods.rb

@@ -21,7 +21,7 @@ module ActiveRecord
     #
     # ==== Parameters
     #
-    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>,
+    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>["user_name = ?", username]</tt>,
     #   or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
     # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
     # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
@@ -54,7 +54,7 @@ module ActiveRecord
     #   Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
     #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
     #   Person.find([1])     # returns an array for the object with ID = 1
-    #   Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
+    #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
     # Note that returned records may not be in the same order as the ids you
     # provide since database rows are unordered. Give an explicit <tt>:order</tt>
@@ -63,23 +63,23 @@ module ActiveRecord
     # ==== Examples
     #
     #   # find first
-    #   Person.find(:first) # returns the first object fetched by SELECT * FROM people
-    #   Person.find(:first, :conditions => [ "user_name = ?", user_name])
-    #   Person.find(:first, :conditions => [ "user_name = :u", { :u => user_name }])
-    #   Person.find(:first, :order => "created_on DESC", :offset => 5)
+    #   Person.first # returns the first object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).first
+    #   Person.where(["user_name = :u", { :u => user_name }]).first
+    #   Person.order("created_on DESC").offset(5).first
     #
     #   # find last
-    #   Person.find(:last) # returns the last object fetched by SELECT * FROM people
-    #   Person.find(:last, :conditions => [ "user_name = ?", user_name])
-    #   Person.find(:last, :order => "created_on DESC", :offset => 5)
+    #   Person.last # returns the last object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).last
+    #   Person.order("created_on DESC").offset(5).last
     #
     #   # find all
-    #   Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people
-    #   Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
-    #   Person.find(:all, :conditions => { :friends => ["Bob", "Steve", "Fred"] }
-    #   Person.find(:all, :offset => 10, :limit => 10)
-    #   Person.find(:all, :include => [ :account, :friends ])
-    #   Person.find(:all, :group => "category")
+    #   Person.all # returns an array of objects for all the rows fetched by SELECT * FROM people
+    #   Person.where(["category IN (?)", categories]).limit(50).all
+    #   Person.where({ :friends => ["Bob", "Steve", "Fred"] }).all
+    #   Person.offset(10).limit(10).all
+    #   Person.includes([:account, :friends]).all
+    #   Person.group("category").all
     #
     # Example for find with a lock: Imagine two concurrent transactions:
     # each will read <tt>person.visits == 2</tt>, add 1 to it, and save, resulting
@@ -88,7 +88,7 @@ module ActiveRecord
     # expected <tt>person.visits == 4</tt>.
     #
     #   Person.transaction do
-    #     person = Person.find(1, :lock => true)
+    #     person = Person.lock(true).find(1)
     #     person.visits += 1
     #     person.save!
     #   end
@@ -230,7 +230,7 @@ module ActiveRecord
     end
 
     def find_by_attributes(match, attributes, *args)
-      conditions = attributes.inject({}) {|h, a| h[a] = args[attributes.index(a)]; h}
+      conditions = Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
       result = where(conditions).send(match.finder)
 
       if match.bang? && result.blank?
@@ -291,8 +291,8 @@ module ActiveRecord
       record = where(primary_key.eq(id)).first
 
       unless record
-        conditions = arel.wheres.map { |x| x.value }.join(', ')
-        conditions = " [WHERE #{conditions}]" if conditions.present?
+        conditions = arel.where_sql
+        conditions = " [#{conditions}]" if conditions
         raise RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}#{conditions}"
       end
 

data/lib/active_record/relation/predicate_builder.rb

@@ -24,7 +24,9 @@ module ActiveRecord
 
           case value
           when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
-            values = value.to_a
+            values = value.to_a.map { |x|
+              x.respond_to?(:quoted_id) ? x.quoted_id : x
+            }
             attribute.in(values)
           when Range, Arel::Relation
             attribute.in(value)

data/lib/active_record/relation/query_methods.rb

@@ -6,93 +6,133 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     attr_accessor :includes_values, :eager_load_values, :preload_values,
-                  :select_values, :group_values, :order_values, :joins_values, :where_values, :having_values,
+                  :select_values, :group_values, :order_values, :reorder_flag, :joins_values, :where_values, :having_values,
                   :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value
 
     def includes(*args)
-      args.reject! { |a| a.blank? }
-      clone.tap {|r| r.includes_values = (r.includes_values + args).flatten.uniq if args.present? }
+      args.reject! {|a| a.blank? }
+
+      return clone if args.empty?
+
+      relation = clone
+      relation.includes_values = (relation.includes_values + args).flatten.uniq
+      relation
     end
 
     def eager_load(*args)
-      clone.tap {|r| r.eager_load_values += args if args.present? }
+      relation = clone
+      relation.eager_load_values += args unless args.blank?
+      relation
     end
 
     def preload(*args)
-      clone.tap {|r| r.preload_values += args if args.present? }
+      relation = clone
+      relation.preload_values += args unless args.blank?
+      relation
     end
 
-    def select(*args)
+    def select(value = Proc.new)
       if block_given?
-        to_a.select {|*block_args| yield(*block_args) }
+        to_a.select {|*block_args| value.call(*block_args) }
       else
-        clone.tap {|r| r.select_values += args if args.present? }
+        relation = clone
+        relation.select_values += Array.wrap(value)
+        relation
       end
     end
 
     def group(*args)
-      clone.tap {|r| r.group_values += args.flatten if args.present? }
+      relation = clone
+      relation.group_values += args.flatten unless args.blank?
+      relation
     end
 
     def order(*args)
-      clone.tap {|r| r.order_values += args if args.present? }
+      relation = clone
+      relation.order_values += args.flatten unless args.blank?
+      relation
     end
 
     def reorder(*args)
-      clone.tap {|r| r.order_values = args if args.present? }
+      ActiveSupport::Deprecation.warn "reorder is deprecated. Please use except(:order).order(...) instead", caller
+      relation = clone
+      unless args.blank?
+        relation.order_values = args
+        relation.reorder_flag = true
+      end
+      relation
     end
 
     def joins(*args)
+      relation = clone
+
       args.flatten!
-      clone.tap {|r| r.joins_values += args if args.present? }
+      relation.joins_values += args unless args.blank?
+
+      relation
     end
 
     def where(opts, *rest)
-      value = build_where(opts, rest)
-      copy = clone
-      copy.where_values += Array.wrap(value) if value
-      copy
+      relation = clone
+      relation.where_values += build_where(opts, rest) unless opts.blank?
+      relation
     end
 
     def having(*args)
-      value = build_where(*args)
-      clone.tap {|r| r.having_values += Array.wrap(value) if value.present? }
+      relation = clone
+      relation.having_values += build_where(*args) unless args.blank?
+      relation
     end
 
-    def limit(value = true)
-      copy = clone
-      copy.limit_value = value
-      copy
+    def limit(value)
+      relation = clone
+      relation.limit_value = value
+      relation
     end
 
-    def offset(value = true)
-      clone.tap {|r| r.offset_value = value }
+    def offset(value)
+      relation = clone
+      relation.offset_value = value
+      relation
     end
 
     def lock(locks = true)
+      relation = clone
+
       case locks
       when String, TrueClass, NilClass
-        clone.tap {|r| r.lock_value = locks || true }
+        relation.lock_value = locks || true
       else
-        clone.tap {|r| r.lock_value = false }
+        relation.lock_value = false
       end
+
+      relation
     end
 
     def readonly(value = true)
-      clone.tap {|r| r.readonly_value = value }
+      relation = clone
+      relation.readonly_value = value
+      relation
     end
 
-    def create_with(value = true)
-      clone.tap {|r| r.create_with_value = value }
+    def create_with(value)
+      relation = clone
+      relation.create_with_value = value
+      relation
     end
 
-    def from(value = true)
-      clone.tap {|r| r.from_value = value }
+    def from(value)
+      relation = clone
+      relation.from_value = value
+      relation
     end
 
     def extending(*modules, &block)
       modules << Module.new(&block) if block_given?
-      clone.tap {|r| r.send(:apply_modules, *modules) }
+
+      relation = clone
+      relation.send(:apply_modules, modules.flatten)
+      relation
     end
 
     def reverse_order
@@ -103,7 +143,7 @@ module ActiveRecord
         "#{@klass.table_name}.#{@klass.primary_key} DESC" :
         reverse_sql_order(order_clause)
 
-      relation.order Arel::SqlLiteral.new order
+      relation.order(Arel::SqlLiteral.new(order))
     end
 
     def arel
@@ -111,24 +151,23 @@ module ActiveRecord
     end
 
     def custom_join_sql(*joins)
-      arel = table
+      arel = table.select_manager
+
       joins.each do |join|
         next if join.blank?
 
         @implicit_readonly = true
 
         case join
-        when Hash, Array, Symbol
-          if array_of_strings?(join)
-            join_string = join.join(' ')
-            arel = arel.join(Arel::SqlLiteral.new(join_string))
-          end
+        when Array
+          join = Arel.sql(join.join(' ')) if array_of_strings?(join)
         when String
-          arel = arel.join(Arel::SqlLiteral.new(join))
-        else
-          arel = arel.join(join)
+          join = Arel.sql(join)
         end
+
+        arel.join(join)
       end
+
       arel.joins(arel)
     end
 
@@ -138,23 +177,18 @@ module ActiveRecord
       arel = build_joins(arel, @joins_values) unless @joins_values.empty?
 
       (@where_values - ['']).uniq.each do |where|
-        case where
-        when Arel::SqlLiteral
-          arel = arel.where(where)
-        else
-          sql = where.is_a?(String) ? where : where.to_sql
-          arel = arel.where(Arel::SqlLiteral.new("(#{sql})"))
-        end
+        where = Arel.sql(where) if String === where
+        arel = arel.where(Arel::Nodes::Grouping.new(where))
       end
 
-      arel = arel.having(*@having_values.uniq.select{|h| h.present?}) unless @having_values.empty?
+      arel = arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?
 
       arel = arel.take(@limit_value) if @limit_value
       arel = arel.skip(@offset_value) if @offset_value
 
-      arel = arel.group(*@group_values.uniq.select{|g| g.present?}) unless @group_values.empty?
+      arel = arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
 
-      arel = arel.order(*@order_values.uniq.select{|o| o.present?}) unless @order_values.empty?
+      arel = arel.order(*@order_values.uniq.reject{|o| o.blank?}) unless @order_values.empty?
 
       arel = build_select(arel, @select_values.uniq)
 
@@ -164,22 +198,21 @@ module ActiveRecord
       arel
     end
 
+    private
+
     def build_where(opts, other = [])
       case opts
       when String, Array
-        @klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))
+        [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
       when Hash
         attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
         PredicateBuilder.new(table.engine).build_from_hash(attributes, table)
       else
-        opts
+        [opts]
       end
     end
 
-    private
-
     def build_joins(relation, joins)
-      joined_associations = []
       association_joins = []
 
       joins = @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
@@ -203,18 +236,15 @@ module ActiveRecord
 
       join_dependency.join_associations.each do |association|
         if (association_relation = association.relation).is_a?(Array)
-          to_join << [association_relation.first, association.join_class, association.association_join.first]
-          to_join << [association_relation.last, association.join_class, association.association_join.last]
+          to_join << [association_relation.first, association.join_type, association.association_join.first]
+          to_join << [association_relation.last, association.join_type, association.association_join.last]
         else
-          to_join << [association_relation, association.join_class, association.association_join]
+          to_join << [association_relation, association.join_type, association.association_join]
         end
       end
 
-      to_join.each do |tj|
-        unless joined_associations.detect {|ja| ja[0] == tj[0] && ja[1] == tj[1] && ja[2] == tj[2] }
-          joined_associations << tj
-          relation = relation.join(tj[0], tj[1]).on(*tj[2])
-        end
+      to_join.uniq.each do |left, join_type, right|
+        relation = relation.join(left, join_type).on(*right)
       end
 
       relation.join(custom_joins)
@@ -223,22 +253,17 @@ module ActiveRecord
     def build_select(arel, selects)
       unless selects.empty?
         @implicit_readonly = false
-        # TODO: fix this ugly hack, we should refactor the callers to get an ARel compatible array.
-        # Before this change we were passing to ARel the last element only, and ARel is capable of handling an array
-        if selects.all? {|s| s.is_a?(String) || !s.is_a?(Arel::Expression) } && !(selects.last =~ /^COUNT\(/)
-          arel.project(*selects)
-        else
-          arel.project(selects.last)
-        end
+        arel.project(*selects)
       else
         arel.project(Arel::SqlLiteral.new(@klass.quoted_table_name + '.*'))
       end
     end
 
     def apply_modules(modules)
-      values = Array.wrap(modules)
-      @extensions += values if values.present?
-      values.each {|extension| extend(extension) }
+      unless modules.empty?
+        @extensions += modules
+        modules.each {|extension| extend(extension) }
+      end
     end
 
     def reverse_sql_order(order_query)