activerecord 3.0.0.rc → 3.0.0.rc2

data/lib/active_record/railtie.rb

@@ -16,7 +16,11 @@ module ActiveRecord
     config.generators.orm :active_record, :migration => true,
                                           :timestamps => true
 
-    config.app_middleware.insert_after "::ActionDispatch::Callbacks", "ActiveRecord::QueryCache"
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "ActiveRecord::QueryCache"
+
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "ActiveRecord::ConnectionAdapters::ConnectionManagement"
 
     rake_tasks do
       load "active_record/railties/databases.rake"
@@ -74,13 +78,6 @@ module ActiveRecord
       end
     end
 
-    initializer "active_record.add_concurrency_middleware" do |app|
-      if app.config.allow_concurrency
-        app.config.middleware.insert_after "::ActionDispatch::Callbacks",
-          "ActiveRecord::ConnectionAdapters::ConnectionManagement"
-      end
-    end
-
     config.after_initialize do
       ActiveSupport.on_load(:active_record) do
         instantiate_observers

data/lib/active_record/railties/databases.rake

@@ -339,7 +339,7 @@ namespace :db do
   end
 
   namespace :structure do
-    desc "Dump the database structure to a SQL file"
+    desc "Dump the database structure to an SQL file"
     task :dump => :environment do
       abcs = ActiveRecord::Base.configurations
       case abcs[Rails.env]["adapter"]

data/lib/active_record/reflection.rb

@@ -3,14 +3,14 @@ module ActiveRecord
   module Reflection # :nodoc:
     extend ActiveSupport::Concern
 
-    # Reflection allows you to interrogate Active Record classes and objects
-    # about their associations and aggregations. This information can, 
-    # for example, be used in a form builder that took an Active Record object
-    # and created input fields for all of the attributes depending on their type
-    # and displayed the associations to other objects.
+    # Reflection enables to interrogate Active Record classes and objects
+    # about their associations and aggregations. This information can,
+    # for example, be used in a form builder that takes an Active Record object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
     #
-    # You can find the interface for the AggregateReflection and AssociationReflection
-    # classes in the abstract MacroReflection class.
+    # MacroReflection class has info for AggregateReflection and AssociationReflection
+    # classes.
     module ClassMethods
       def create_reflection(macro, name, options, active_record)
         case macro
@@ -24,7 +24,7 @@ module ActiveRecord
         reflection
       end
 
-      # Returns a hash containing all AssociationReflection objects for the current class
+      # Returns a hash containing all AssociationReflection objects for the current class.
       # Example:
       #
       #   Invoice.reflections
@@ -39,17 +39,17 @@ module ActiveRecord
         reflections.values.select { |reflection| reflection.is_a?(AggregateReflection) }
       end
 
-      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol). Example:
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
       #
-      #   Account.reflect_on_aggregation(:balance) # returns the balance AggregateReflection
+      #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
       #
       def reflect_on_aggregation(aggregation)
         reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
       end
 
-      # Returns an array of AssociationReflection objects for all the 
-      # associations in the class. If you only want to reflect on a certain 
-      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>, 
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
       # <tt>:belongs_to</tt>) as the first parameter.
       #
       # Example:
@@ -78,8 +78,7 @@ module ActiveRecord
     end
 
 
-    # Abstract base class for AggregateReflection and AssociationReflection that
-    # describes the interface available for both of those classes. Objects of
+    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
       attr_reader :active_record
@@ -89,36 +88,35 @@ module ActiveRecord
       end
 
       # Returns the name of the macro.
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>:balance</tt> 
-      # <tt>has_many :clients</tt> will return <tt>:clients</tt>
-      def name
-        @name
-      end
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
 
-      # Returns the macro type. 
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>:composed_of</tt>
-      # <tt>has_many :clients</tt> will return <tt>:has_many</tt>
-      def macro
-        @macro
-      end
+      # Returns the macro type.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
 
-      # Returns the hash of options used for the macro.  
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>{ :class_name => "Money" }</tt>
-      # <tt>has_many :clients</tt> will return +{}+
-      def options
-        @options
-      end
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
 
-      # Returns the class for the macro.  
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return the Money class
-      # <tt>has_many :clients</tt> will return the Client class
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
       def klass
         @klass ||= class_name.constantize
       end
 
-      # Returns the class name for the macro.  
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>'Money'</tt>
-      # <tt>has_many :clients</tt> will return <tt>'Client'</tt>
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
       def class_name
         @class_name ||= options[:class_name] || derive_class_name
       end
@@ -133,11 +131,6 @@ module ActiveRecord
         @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
       end
 
-      # Returns +true+ if +self+ is a +belongs_to+ reflection.
-      def belongs_to?
-        macro == :belongs_to
-      end
-
       private
         def derive_class_name
           name.to_s.camelize
@@ -145,15 +138,15 @@ module ActiveRecord
     end
 
 
-    # Holds all the meta-data about an aggregation as it was specified in the 
+    # Holds all the meta-data about an aggregation as it was specified in the
     # Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
     end
 
-    # Holds all the meta-data about an association as it was specified in the 
+    # Holds all the meta-data about an association as it was specified in the
     # Active Record class.
     class AssociationReflection < MacroReflection #:nodoc:
-      # Returns the target association's class:
+      # Returns the target association's class.
       #
       #   class Author < ActiveRecord::Base
       #     has_many :books
@@ -162,7 +155,7 @@ module ActiveRecord
       #   Author.reflect_on_association(:books).klass
       #   # => Book
       #
-      # <b>Note:</b> do not call +klass.new+ or +klass.create+ to instantiate
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
       # a new association object. Use +build_association+ or +create_association+
       # instead. This allows plugins to hook into association object creation.
       def klass
@@ -209,6 +202,10 @@ module ActiveRecord
         @primary_key_name ||= options[:foreign_key] || derive_primary_key_name
       end
 
+      def primary_key_column
+        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+      end
+
       def association_foreign_key
         @association_foreign_key ||= @options[:association_foreign_key] || class_name.foreign_key
       end
@@ -273,7 +270,7 @@ module ActiveRecord
       end
 
       # Returns whether or not this association reflection is for a collection
-      # association. Returns +true+ if the +macro+ is one of +has_many+ or
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
       # +has_and_belongs_to_many+, +false+ otherwise.
       def collection?
         @collection
@@ -283,7 +280,7 @@ module ActiveRecord
       # the parent's validation.
       #
       # Unless you explicitly disable validation with
-      # <tt>:validate => false</tt>, it will take place when:
+      # <tt>:validate => false</tt>, validation will take place when:
       #
       # * you explicitly enable validation; <tt>:validate => true</tt>
       # * you use autosave; <tt>:autosave => true</tt>
@@ -303,6 +300,11 @@ module ActiveRecord
         dependent_conditions
       end
 
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?
+        macro == :belongs_to
+      end
+
       private
         def derive_class_name
           class_name = name.to_s.camelize
@@ -327,8 +329,6 @@ module ActiveRecord
       # Gets the source of the through reflection.  It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
-      # (The <tt>:tags</tt> association on Tagging below.)
-      #
       #   class Post < ActiveRecord::Base
       #     has_many :taggings
       #     has_many :tags, :through => :taggings
@@ -339,7 +339,7 @@ module ActiveRecord
       end
 
       # Returns the AssociationReflection object specified in the <tt>:through</tt> option
-      # of a HasManyThrough or HasOneThrough association. Example:
+      # of a HasManyThrough or HasOneThrough association.
       #
       #   class Post < ActiveRecord::Base
       #     has_many :taggings

data/lib/active_record/relation.rb

@@ -67,7 +67,8 @@ module ActiveRecord
       preload +=  @includes_values unless eager_loading?
       preload.each {|associations| @klass.send(:preload_associations, @records, associations) }
 
-      # @readonly_value is true only if set explicitly. @implicit_readonly is true if there are JOINS and no explicit SELECT.
+      # @readonly_value is true only if set explicitly. @implicit_readonly is true if there
+      # are JOINS and no explicit SELECT.
       readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value
       @records.each { |record| record.readonly! } if readonly
 
@@ -99,7 +100,7 @@ module ActiveRecord
       if block_given?
         to_a.many? { |*block_args| yield(*block_args) }
       else
-        @limit_value.present? ? to_a.many? : size > 1
+        @limit_value ? to_a.many? : size > 1
       end
     end
 
@@ -108,7 +109,7 @@ module ActiveRecord
     # ==== Example
     #
     #   Comment.where(:post_id => 1).scoping do
-    #     Comment.first #=> SELECT * FROM comments WHERE post_id = 1
+    #     Comment.first # SELECT * FROM comments WHERE post_id = 1
     #   end
     #
     # Please check unscoped if you want to remove all previous scopes (including
@@ -130,7 +131,8 @@ module ActiveRecord
     # ==== Parameters
     #
     # * +updates+ - A string, array, or hash representing the SET part of an SQL statement.
-    # * +conditions+ - A string, array, or hash representing the WHERE part of an SQL statement. See conditions in the intro.
+    # * +conditions+ - A string, array, or hash representing the WHERE part of an SQL statement.
+    #   See conditions in the intro.
     # * +options+ - Additional options are <tt>:limit</tt> and <tt>:order</tt>, see the examples for usage.
     #
     # ==== Examples
@@ -144,7 +146,7 @@ module ActiveRecord
     #   # Update all avatars migrated more than a week ago
     #   Avatar.update_all ['migrated_at = ?', Time.now.utc], ['migrated_at > ?', 1.week.ago]
     #
-    #   # Update all books that match our conditions, but limit it to 5 ordered by date
+    #   # Update all books that match conditions, but limit it to 5 ordered by date
     #   Book.update_all "author = 'David'", "title LIKE '%Rails%'", :order => 'created_at', :limit => 5
     def update_all(updates, conditions = nil, options = {})
       if conditions || options.present?
@@ -152,7 +154,7 @@ module ActiveRecord
       else
         # Apply limit and order only if they're both present
         if @limit_value.present? == @order_values.present?
-          arel.update(@klass.send(:sanitize_sql_for_assignment, updates))
+          arel.update(Arel::SqlLiteral.new(@klass.send(:sanitize_sql_for_assignment, updates)))
         else
           except(:limit, :order).update_all(updates)
         end
@@ -165,14 +167,14 @@ module ActiveRecord
     # ==== Parameters
     #
     # * +id+ - This should be the id or an array of ids to be updated.
-    # * +attributes+ - This should be a hash of attributes to be set on the object, or an array of hashes.
+    # * +attributes+ - This should be a hash of attributes or an array of hashes.
     #
     # ==== Examples
     #
-    #   # Updating one record:
+    #   # Updates one record
     #   Person.update(15, :user_name => 'Samuel', :group => 'expert')
     #
-    #   # Updating multiple records:
+    #   # Updates multiple records
     #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
     #   Person.update(people.keys, people.values)
     def update(id, attributes)
@@ -262,8 +264,8 @@ module ActiveRecord
     #   Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
     #   Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else'])
     #
-    # Both calls delete the affected posts all at once with a single DELETE statement. 
-    # If you need to destroy dependent associations or call your <tt>before_*</tt> or 
+    # Both calls delete the affected posts all at once with a single DELETE statement.
+    # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the +destroy_all+ method instead.
     def delete_all(conditions = nil)
       conditions ? where(conditions).delete_all : arel.delete.tap { reset }
@@ -314,14 +316,19 @@ module ActiveRecord
       @to_sql ||= arel.to_sql
     end
 
+    def where_values_hash
+          Hash[@where_values.find_all { |w|
+            w.respond_to?(:operator) && w.operator == :==
+          }.map { |where|
+            [where.operand1.name,
+             where.operand2.respond_to?(:value) ?
+             where.operand2.value : where.operand2]
+        }]
+    end
+
     def scope_for_create
       @scope_for_create ||= begin
-        @create_with_value || @where_values.inject({}) do |hash, where|
-          if where.is_a?(Arel::Predicates::Equality)
-            hash[where.operand1.name] = where.operand2.respond_to?(:value) ? where.operand2.value : where.operand2
-          end
-          hash
-        end
+        @create_with_value || where_values_hash
       end
     end
 
@@ -371,7 +378,7 @@ module ActiveRecord
 
     def references_eager_loaded_tables?
       # always convert table names to downcase as in Oracle quoted table names are in uppercase
-      joined_tables = (tables_in_string(arel.joins(arel)) + [table.name, table.table_alias]).compact.map(&:downcase).uniq
+      joined_tables = (tables_in_string(arel.joins(arel)) + [table.name, table.table_alias]).compact.map{ |t| t.downcase }.uniq
       (tables_in_string(to_sql) - joined_tables).any?
     end
 
@@ -379,7 +386,7 @@ module ActiveRecord
       return [] if string.blank?
       # always convert table names to downcase as in Oracle quoted table names are in uppercase
       # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
-      string.scan(/([a-zA-Z_][\.\w]+).?\./).flatten.map(&:downcase).uniq - ['raw_sql_']
+      string.scan(/([a-zA-Z_][\.\w]+).?\./).flatten.map{ |s| s.downcase }.uniq - ['raw_sql_']
     end
 
   end

data/lib/active_record/relation/batches.rb

@@ -50,9 +50,9 @@ module ActiveRecord
     def find_in_batches(options = {})
       relation = self
 
-       if orders.present? || taken.present?
-         ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
-       end
+      if orders.present? || taken.present?
+        ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+      end
 
       if (finder_options = options.except(:start, :batch_size)).present?
         raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order].present?
@@ -73,7 +73,7 @@ module ActiveRecord
         break if records.size < batch_size
 
         if primary_key_offset = records.last.id
-          records = relation.where(primary_key.gt(primary_key_offset)).all
+          records = relation.where(primary_key.gt(primary_key_offset)).to_a
         else
           raise "Primary key not included in the custom select clause"
         end

data/lib/active_record/relation/calculations.rb

@@ -1,30 +1,38 @@
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
 
 module ActiveRecord
   module Calculations
     # Count operates using three different approaches.
     #
     # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
-    # * Count using column: By passing a column name to count, it will return a count of all the rows for the model with supplied column present
+    # * Count using column: By passing a column name to count, it will return a count of all the
+    #   rows for the model with supplied column present
     # * Count using options will find the row count matched by the options used.
     #
     # The third approach, count using options, accepts an option hash as the only parameter. The options are:
     #
-    # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
+    # * <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" (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 will be returned read-only since they will have attributes that do not correspond to the table's columns.
+    #   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 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. The symbols named refer
-    #   to already defined associations. When using named associations, count returns the number of DISTINCT items for the model you're counting.
+    # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs.
+    #   The symbols named refer to already defined associations. When using named associations, count
+    #   returns the number of DISTINCT items for the model you're counting.
     #   See eager loading under Associations.
     # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
     # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-    # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example, want to do a join but not
+    # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example,
+    #   want to do a join but not
     #   include the joined columns.
-    # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
-    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
-    #   of a database view).
+    # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as
+    #   SELECT COUNT(DISTINCT posts.id) ...
+    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an
+    #   alternate table name (or even the name of a database view).
     #
     # Examples for counting all:
     #   Person.count         # returns the total count of all people
@@ -34,12 +42,19 @@ module ActiveRecord
     #
     # Examples for count with options:
     #   Person.count(:conditions => "age > 26")
-    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
-    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins.
+    #
+    #   # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
+    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job)
+    #
+    #   # finds the number of rows matching the conditions and joins.
+    #   Person.count(:conditions => "age > 26 AND job.salary > 60000",
+    #                :joins => "LEFT JOIN jobs on jobs.person_id = person.id")
+    #
     #   Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
     #   Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
     #
-    # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.  Use Person.count instead.
+    # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.
+    # Use Person.count instead.
     def count(column_name = nil, options = {})
       column_name, options = nil, column_name if column_name.is_a?(Hash)
       calculate(:count, column_name, options)
@@ -80,13 +95,15 @@ module ActiveRecord
       calculate(:sum, column_name, options)
     end
 
-    # This calculates aggregate values in the given column.  Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
-    # Options such as <tt>:conditions</tt>, <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
+    # This calculates aggregate values in the given column.  Methods for count, sum, average,
+    # minimum, and maximum have been added as shortcuts. Options such as <tt>:conditions</tt>,
+    # <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
     #
     # There are two basic forms of output:
-    #   * Single aggregate value: The single value is type cast to Fixnum 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 by the <tt>:group</tt> option.  It takes either a column name, or the name
-    #     of a belongs_to association.
+    #   * Single aggregate value: The single value is type cast to Fixnum 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 by the
+    #     <tt>:group</tt> option.  It takes either a column name, or the name of a belongs_to association.
     #
     #       values = Person.maximum(:age, :group => 'last_name')
     #       puts values["Drake"]
@@ -102,21 +119,30 @@ module ActiveRecord
     #       end
     #
     # Options:
-    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
-    # * <tt>:include</tt>: Eager loading, see Associations for details.  Since calculations don't load anything, the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
-    # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
-    #   The records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ].
+    #   See conditions in the intro to ActiveRecord::Base.
+    # * <tt>:include</tt>: Eager loading, see Associations for details.  Since calculations don't load anything,
+    #   the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
+    # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id".
+    #   (Rarely needed).
+    #   The records will be returned read-only since they will have attributes that do not correspond to the
+    #   table's columns.
     # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
     # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-    # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
-    #   include the joined columns.
-    # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
+    # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example
+    #   want to do a join, but not include the joined columns.
+    # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as
+    #   SELECT COUNT(DISTINCT posts.id) ...
     #
     # Examples:
     #   Person.calculate(:count, :all) # The same as Person.count
     #   Person.average(:age) # SELECT AVG(age) FROM people...
-    #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for everyone with a last name other than 'Drake'
-    #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
+    #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for
+    #                                                                    # everyone with a last name other than 'Drake'
+    #
+    #   # Selects the minimum age for any family without any minors
+    #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name)
+    #
     #   Person.sum("2 * age")
     def calculate(operation, column_name, options = {})
       if options.except(:distinct).present?
@@ -137,19 +163,17 @@ module ActiveRecord
     def perform_calculation(operation, column_name, options = {})
       operation = operation.to_s.downcase
 
+      distinct = nil
+
       if operation == "count"
         column_name ||= (select_for_count || :all)
 
-        joins = arel.joins(arel)
-        if joins.present? && joins =~ /LEFT OUTER/i
+        if arel.joins(arel) =~ /LEFT OUTER/i
           distinct = true
           column_name = @klass.primary_key if column_name == :all
         end
 
-        distinct = nil if column_name.to_s =~ /\s*DISTINCT\s+/i
-        distinct ||= options[:distinct]
-      else
-        distinct = nil
+        distinct = nil if column_name =~ /\s*DISTINCT\s+/i
       end
 
       distinct = options[:distinct] || distinct
@@ -256,7 +280,7 @@ module ActiveRecord
 
     def select_for_count
       if @select_values.present?
-        select = @select_values.join(", ") 
+        select = @select_values.join(", ")
         select if select !~ /(,|\*)/
       end
     end