Module: ActiveRecord::Calculations::ClassMethods
- Defined in:
- lib/active_record/calculations.rb
Instance Method Summary collapse
-
#average(column_name, options = {}) ⇒ Object
Calculates average value on a given column.
-
#calculate(operation, column_name, options = {}) ⇒ Object
This calculates aggregate values in the given column: Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
-
#count(*args) ⇒ Object
Count operates using three different approaches.
-
#maximum(column_name, options = {}) ⇒ Object
Calculates the maximum value on a given column.
-
#minimum(column_name, options = {}) ⇒ Object
Calculates the minimum value on a given column.
-
#sum(column_name, options = {}) ⇒ Object
Calculates the sum value on a given column.
Instance Method Details
#average(column_name, options = {}) ⇒ Object
Calculates average value on a given column. The value is returned as a float. See #calculate for examples with options.
Person.average('age')
73 74 75 |
# File 'lib/active_record/calculations.rb', line 73 def average(column_name, = {}) calculate(:avg, column_name, ) end |
#calculate(operation, column_name, options = {}) ⇒ Object
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. -
: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
134 135 136 137 138 139 140 141 142 143 144 145 146 |
# File 'lib/active_record/calculations.rb', line 134 def calculate(operation, column_name, = {}) (operation, ) column_name = [:select] if [:select] column_name = '*' if column_name == :all column = column_for column_name aggregate = select_aggregate(operation, column_name, ) aggregate_alias = column_alias_for(operation, column_name) if [:group] execute_grouped_calculation(operation, column_name, column, aggregate, aggregate_alias, ) else execute_simple_calculation(operation, column_name, column, aggregate, aggregate_alias, ) end end |
#count(*args) ⇒ Object
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 by conditions or joins: For backwards compatibility, you can pass in
conditions
andjoins
as individual parameters. -
Count using options will find the row count matched by the options used.
The last approach, count using options, accepts an option hash as the only parameter. The options are:
-
:conditions
: An SQL fragment like “administrator = 1” or [ “user_name = ?”, username ]. See conditions in the intro. -
: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. -
:include
: 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 DISTINCT items for the model you’re counting. See eager loading under Associations. -
: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 for counting all:
Person.count # returns the total count of all people
Examples for count by conditions
and joins
(for backwards compatibility):
Person.count("age > 26") # returns the number of people older than 26
Person.find("age > 26 AND job.salary > 60000", "LEFT JOIN jobs on jobs.person_id = person.id") # returns the total number of rows matching the conditions and joins fetched by SELECT COUNT(*).
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.
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: Person.count(:all) will not work because it will use :all as the condition. Use Person.count instead.
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
# File 'lib/active_record/calculations.rb', line 44 def count(*args) = {} column_name = :all # For backwards compatibility, we need to handle both count(conditions=nil, joins=nil) or count(options={}) or count(column_name=:all, options={}). if args.size >= 0 && args.size <= 2 if args.first.is_a?(Hash) = args.first elsif args[1].is_a?(Hash) = args[1] column_name = args.first else # Handle legacy paramter options: def count(conditions=nil, joins=nil) .merge!(:conditions => args[0]) if args.length > 0 .merge!(:joins => args[1]) if args.length > 1 end else raise(ArgumentError, "Unexpected parameters passed to count(*args): expected either count(conditions=nil, joins=nil) or count(options={})") end if [:include] || scope(:find, :include) count_with_associations() else calculate(:count, column_name, ) end end |
#maximum(column_name, options = {}) ⇒ Object
Calculates the maximum value on a given column. The value is returned with the same data type of the column.. See #calculate for examples with options.
Person.maximum('age')
87 88 89 |
# File 'lib/active_record/calculations.rb', line 87 def maximum(column_name, = {}) calculate(:max, column_name, ) end |
#minimum(column_name, options = {}) ⇒ Object
Calculates the minimum value on a given column. The value is returned with the same data type of the column.. See #calculate for examples with options.
Person.minimum('age')
80 81 82 |
# File 'lib/active_record/calculations.rb', line 80 def minimum(column_name, = {}) calculate(:min, column_name, ) end |
#sum(column_name, options = {}) ⇒ Object
Calculates the sum value on a given column. The value is returned with the same data type of the column.. See #calculate for examples with options.
Person.sum('age')
94 95 96 |
# File 'lib/active_record/calculations.rb', line 94 def sum(column_name, = {}) calculate(:sum, column_name, ) end |