Module: ActiveRecord::Calculations
- Included in:
- Relation
- Defined in:
- lib/active_record/relation/calculations.rb
Instance Method Summary collapse
-
#average(column_name, options = {}) ⇒ Object
Calculates the average value on a given column.
-
#calculate(operation, column_name, options = {}) ⇒ Object
This calculates aggregate values in the given column.
-
#count(column_name = nil, options = {}) ⇒ Object
Count the records.
-
#ids ⇒ Object
Pluck all the ID’s for the relation using the table’s primary key.
-
#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.
-
#pluck(*column_names) ⇒ Object
Use
pluck
as a shortcut to select one or more attributes without loading a bunch of records just to grab the attributes you want. -
#sum(*args) ⇒ Object
Calculates the sum of values on a given column.
Instance Method Details
#average(column_name, options = {}) ⇒ Object
Calculates the average value on a given column. Returns nil
if there’s no row. See calculate
for examples with options.
Person.average(:age) # => 35.8
55 56 57 58 59 |
# File 'lib/active_record/relation/calculations.rb', line 55 def average(column_name, = {}) # TODO: Remove options argument as soon we remove support to # activerecord-deprecated_finders. calculate(:average, 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.
There are two basic forms of output:
* Single aggregate value: The single value is type cast to Integer 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. It
takes either a column name, or the name of a belongs_to association.
values = Person.group('last_name').maximum(:age)
puts values["Drake"]
# => 43
drake = Family.find_by(last_name: 'Drake')
values = Person.group(:family).maximum(:age) # Person belongs_to :family
puts values[drake]
# => 43
values.each do |family, max_age|
...
end
Person.calculate(:count, :all) # The same as Person.count
Person.average(:age) # SELECT AVG(age) FROM people...
# Selects the minimum age for any family without any minors
Person.group(:last_name).having("min(age) > 17").minimum(:age)
Person.sum("2 * age")
123 124 125 126 127 128 129 130 131 132 133 134 135 |
# File 'lib/active_record/relation/calculations.rb', line 123 def calculate(operation, column_name, = {}) # TODO: Remove options argument as soon we remove support to # activerecord-deprecated_finders. if column_name.is_a?(Symbol) && attribute_alias?(column_name) column_name = attribute_alias(column_name) end if has_include?(column_name) construct_relation_for_association_calculations.calculate(operation, column_name, ) else perform_calculation(operation, column_name, ) end end |
#count(column_name = nil, options = {}) ⇒ Object
Count the records.
Person.count
# => the total count of all people
Person.count(:age)
# => returns the total count of all people whose age is present in database
Person.count(:all)
# => performs a COUNT(*) (:all is an alias for '*')
Person.distinct.count(:age)
# => counts the number of different age values
If count
is used with group
, it returns a Hash whose keys represent the aggregated column, and the values are the respective amounts:
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 database is thrown.
38 39 40 41 42 43 44 45 46 47 48 49 |
# File 'lib/active_record/relation/calculations.rb', line 38 def count(column_name = nil, = {}) if .present? && !ActiveRecord.const_defined?(:DeprecatedFinders) raise ArgumentError, "Relation#count does not support finder options anymore. " \ "Please build a scope and then call count on it or use the " \ "activerecord-deprecated_finders gem to enable this functionality." end # TODO: Remove options argument as soon we remove support to # activerecord-deprecated_finders. calculate(:count, column_name, ) end |
#ids ⇒ Object
Pluck all the ID’s for the relation using the table’s primary key
Person.ids # SELECT people.id FROM people
Person.joins(:companies).ids # SELECT people.id FROM people INNER JOIN companies ON companies.person_id = people.id
195 196 197 |
# File 'lib/active_record/relation/calculations.rb', line 195 def ids pluck primary_key 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, or nil
if there’s no row. See calculate
for examples with options.
Person.maximum(:age) # => 93
77 78 79 80 81 |
# File 'lib/active_record/relation/calculations.rb', line 77 def maximum(column_name, = {}) # TODO: Remove options argument as soon we remove support to # activerecord-deprecated_finders. calculate(:maximum, 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, or nil
if there’s no row. See calculate
for examples with options.
Person.minimum(:age) # => 7
66 67 68 69 70 |
# File 'lib/active_record/relation/calculations.rb', line 66 def minimum(column_name, = {}) # TODO: Remove options argument as soon we remove support to # activerecord-deprecated_finders. calculate(:minimum, column_name, ) end |
#pluck(*column_names) ⇒ Object
Use pluck
as a shortcut to select one or more attributes without loading a bunch of records just to grab the attributes you want.
Person.pluck(:name)
instead of
Person.all.map(&:name)
Pluck returns an Array
of attribute values type-casted to match the plucked column names, if they can be deduced. Plucking an SQL fragment returns String values by default.
Person.pluck(:id)
# SELECT people.id FROM people
# => [1, 2, 3]
Person.pluck(:id, :name)
# SELECT people.id, people.name FROM people
# => [[1, 'David'], [2, 'Jeremy'], [3, 'Jose']]
Person.pluck('DISTINCT role')
# SELECT DISTINCT role FROM people
# => ['admin', 'member', 'guest']
Person.where(age: 21).limit(5).pluck(:id)
# SELECT people.id FROM people WHERE people.age = 21 LIMIT 5
# => [2, 3]
Person.pluck('DATEDIFF(updated_at, created_at)')
# SELECT DATEDIFF(updated_at, created_at) FROM people
# => ['0', '27761', '173']
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 |
# File 'lib/active_record/relation/calculations.rb', line 170 def pluck(*column_names) column_names.map! do |column_name| if column_name.is_a?(Symbol) && attribute_alias?(column_name) attribute_alias(column_name) else column_name.to_s end end if has_include?(column_names.first) construct_relation_for_association_calculations.pluck(*column_names) else relation = spawn relation.select_values = column_names.map { |cn| columns_hash.key?(cn) ? arel_table[cn] : cn } result = klass.connection.select_all(relation.arel, nil, relation.arel.bind_values + bind_values) result.cast_values(klass.column_types) end end |
#sum(*args) ⇒ Object
Calculates the sum of values on a given column. The value is returned with the same data type of the column, 0 if there’s no row. See calculate
for examples with options.
Person.sum(:age) # => 4562
88 89 90 |
# File 'lib/active_record/relation/calculations.rb', line 88 def sum(*args) calculate(:sum, *args) end |