From 8f63dcb64873fe94c5d837a49f742d41589ce311 Mon Sep 17 00:00:00 2001 From: Pratik Naik Date: Tue, 19 Jan 2010 22:09:04 +0530 Subject: Move the only remaining calculation method calculate() to Relation --- activerecord/lib/active_record/calculations.rb | 54 +------------ .../active_record/relation/calculation_methods.rb | 91 +++++++++++++++------- 2 files changed, 62 insertions(+), 83 deletions(-) (limited to 'activerecord') diff --git a/activerecord/lib/active_record/calculations.rb b/activerecord/lib/active_record/calculations.rb index 41acf7be4e..ea63617c52 100644 --- a/activerecord/lib/active_record/calculations.rb +++ b/activerecord/lib/active_record/calculations.rb @@ -3,59 +3,7 @@ module ActiveRecord extend ActiveSupport::Concern module ClassMethods - delegate :count, :average, :minimum, :maximum, :sum, :to => :scoped - - # This calculates aggregate values in the given column. Methods for count, sum, average, minimum, and maximum have been added as shortcuts. - # Options such as :conditions, :order, :group, :having, and :joins 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 :group 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"] - # => 43 - # - # drake = Family.find_by_last_name('Drake') - # values = Person.maximum(:age, :group => :family) # Person belongs_to :family - # puts values[drake] - # => 43 - # - # values.each do |family, max_age| - # ... - # end - # - # Options: - # * :conditions - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base. - # * :include: 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. - # * :joins - 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. - # * :order - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations). - # * :group - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause. - # * :select - 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. - # * :distinct - 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.sum("2 * age") - def calculate(operation, column_name, options = {}) - construct_calculation_arel(options).calculate(operation, column_name, options.slice(:distinct)) - rescue ThrowResult - 0 - end - - private - - def construct_calculation_arel(options = {}) - relation = scoped.apply_finder_options(options.except(:distinct)) - (relation.eager_loading? || relation.includes_values.present?) ? relation.send(:construct_relation_for_association_calculations) : relation - end - + delegate :count, :average, :minimum, :maximum, :sum, :calculate, :to => :scoped end end end diff --git a/activerecord/lib/active_record/relation/calculation_methods.rb b/activerecord/lib/active_record/relation/calculation_methods.rb index 53d8594da8..155e90333c 100644 --- a/activerecord/lib/active_record/relation/calculation_methods.rb +++ b/activerecord/lib/active_record/relation/calculation_methods.rb @@ -40,16 +40,7 @@ module ActiveRecord # Note: Person.count(:all) will not work because it will use :all 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) - column_name = select_for_count unless column_name - distinct = options.delete(:distinct) - - if options.any? - calculation_relation(options).count(column_name, :distinct => distinct) - else - relation_for_association_calculations.calculate(:count, column_name || :all, :distinct => distinct) - end - rescue ThrowResult - 0 + calculate(:count, column_name, options) end # Calculates the average value on a given column. The value is returned as @@ -58,7 +49,7 @@ module ActiveRecord # # Person.average('age') # => 35.8 def average(column_name, options = {}) - calculation_relation(options).calculate(:average, column_name) + calculate(:average, column_name, options) end # Calculates the minimum value on a given column. The value is returned @@ -67,7 +58,7 @@ module ActiveRecord # # Person.minimum('age') # => 7 def minimum(column_name, options = {}) - calculation_relation(options).calculate(:minimum, column_name) + calculate(:minimum, column_name, options) end # Calculates the maximum value on a given column. The value is returned @@ -76,7 +67,7 @@ module ActiveRecord # # Person.maximum('age') # => 93 def maximum(column_name, options = {}) - calculation_relation(options).calculate(:maximum, column_name) + calculate(:maximum, column_name, options) end # Calculates the sum of values on a given column. The value is returned @@ -85,13 +76,69 @@ module ActiveRecord # # Person.sum('age') # => 4562 def sum(column_name, options = {}) - calculation_relation(options).calculate(:sum, column_name) + 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 :conditions, :order, :group, :having, and :joins 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 :group 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"] + # => 43 + # + # drake = Family.find_by_last_name('Drake') + # values = Person.maximum(:age, :group => :family) # Person belongs_to :family + # puts values[drake] + # => 43 + # + # values.each do |family, max_age| + # ... + # end + # + # Options: + # * :conditions - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base. + # * :include: 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. + # * :joins - 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. + # * :order - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations). + # * :group - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause. + # * :select - 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. + # * :distinct - 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.sum("2 * age") def calculate(operation, column_name, options = {}) + if options.except(:distinct).present? + apply_finder_options(options.except(:distinct)).calculate(operation, column_name, :distinct => options[:distinct]) + else + if eager_loading? || includes_values.present? + construct_relation_for_association_calculations.calculate(operation, column_name, options) + else + perform_calculation(operation, column_name, options) + end + end + rescue ThrowResult + 0 + end + + private + + def perform_calculation(operation, column_name, options = {}) operation = operation.to_s.downcase if operation == "count" + column_name ||= (select_for_count || :all) + joins = arel.joins(arel) if joins.present? && joins =~ /LEFT OUTER/i distinct = true @@ -112,22 +159,6 @@ module ActiveRecord else return execute_simple_calculation(operation, column_name, distinct) end - rescue ThrowResult - 0 - end - - def calculation_relation(options = {}) - if options.present? - apply_finder_options(options.except(:distinct)).calculation_relation - else - relation_for_association_calculations - end - end - - private - - def relation_for_association_calculations - (eager_loading? || includes_values.present?) ? construct_relation_for_association_calculations : self end def execute_simple_calculation(operation, column_name, distinct) #:nodoc: -- cgit v1.2.3