модуль ActiveRecord::Calculations

Вычисления Active Record

Публичные методы экземпляров

async_average(column_name) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 112
def async_average(column_name)
  async.average(column_name)
end

Аналогично average, но выполняет запрос асинхронно и возвращает ActiveRecord::Promise.

async_count(column_name = nil) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 98
def async_count(column_name = nil)
  async.count(column_name)
end

Аналогично count, но выполняет запрос асинхронно и возвращает ActiveRecord::Promise.

async_ids() Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 370
def async_ids
  async.ids
end

Аналогично ids, но выполняет запрос асинхронно и возвращает ActiveRecord::Promise.

async_maximum(column_name) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 142
def async_maximum(column_name)
  async.maximum(column_name)
end

Аналогично maximum, но выполняет запрос асинхронно и возвращает ActiveRecord::Promise.

async_minimum(column_name) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 127
def async_minimum(column_name)
  async.minimum(column_name)
end

Аналогично minimum, но выполняет запрос асинхронно и возвращает ActiveRecord::Promise.

async_pick(*column_names) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 326
def async_pick(*column_names)
  async.pick(*column_names)
end

Аналогично pick, но выполняет запрос асинхронно и возвращает ActiveRecord::Promise.

async_pluck(*column_names) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 297
def async_pluck(*column_names)
  async.pluck(*column_names)
end

Аналогично pluck, но выполняет запрос асинхронно и возвращает ActiveRecord::Promise.

async_sum(identity_or_column = nil) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 161
def async_sum(identity_or_column = nil)
  async.sum(identity_or_column)
end

Аналогично sum, но выполняет запрос асинхронно и возвращает ActiveRecord::Promise.

average(column_name) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 106
def average(column_name)
  calculate(:average, column_name)
end

Вычисляет среднее значение по заданному столбцу. Возвращает nil , если нет строк. См. calculate для примеров с параметрами.

Person.average(:age) # => 35.8

calculate(operation, column_name) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 196
def calculate(operation, column_name)
  operation = operation.to_s.downcase

  if @none
    case operation
    when "count", "sum"
      result = group_values.any? ? Hash.new : 0
      return @async ? Promise::Complete.new(result) : result
    when "average", "minimum", "maximum"
      result = group_values.any? ? Hash.new : nil
      return @async ? Promise::Complete.new(result) : result
    end
  end

  if has_include?(column_name)
    relation = apply_join_dependency

    if operation == "count"
      unless distinct_value || distinct_select?(column_name || select_for_count)
        relation.distinct!
        relation.select_values = [ klass.primary_key || table[Arel.star] ]
      end
      # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
      relation.order_values = [] if group_values.empty?
    end

    relation.calculate(operation, column_name)
  else
    perform_calculation(operation, column_name)
  end
end

Вычисляет агрегированные значения в заданном столбце. Методы для count, sum, average, minimum и maximum добавлены в качестве сокращений.

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")

Существуют два основных формата вывода:

Единственное агрегированное значение: единственное значение преобразуется в тип Integer для COUNT, Float для AVG и в тип заданного столбца для всех остальных случаев.

Группированные значения: возвращает упорядоченный массив значений и группирует их. Принимает либо имя столбца, либо имя ассоциации belongs_to.

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

count(column_name = nil) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 84
def count(column_name = nil)
  if block_given?
    unless column_name.nil?
      raise ArgumentError, "Column name argument is not supported when a block is passed."
    end

    super()
  else
    calculate(:count, column_name)
  end
end

Подсчитывает записи.

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

Если count используется с Relation#group, возвращается Hash, ключи которого представляют агрегированный столбец, а значения — соответствующие количества:

Person.group(:city).count
# => { 'Rome' => 5, 'Paris' => 3 }

Если count используется с Relation#group для нескольких столбцов, возвращается Hash, ключи которого — массив, содержащий индивидуальные значения каждого столбца, а значение каждого ключа — count.

Article.group(:status, :category).count
# =>  {["draft", "business"]=>10, ["draft", "technology"]=>4, ["published", "technology"]=>2}

Если count используется с Relation#select, он будет подсчитывать выбранные столбцы:

Person.select(:age).count
# => counts the number of different age values

Примечание: не все допустимые выражения Relation#select являются допустимыми выражениями count. Конкретные особенности зависят от базы данных. В недопустимых случаях выбрасывается ошибка базы данных.

Вызывает метод суперкласса

ids() Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 334
def ids
  primary_key_array = Array(primary_key)

  if loaded?
    result = records.map do |record|
      if primary_key_array.one?
        record._read_attribute(primary_key_array.first)
      else
        primary_key_array.map { |column| record._read_attribute(column) }
      end
    end
    return @async ? Promise::Complete.new(result) : result
  end

  if has_include?(primary_key)
    relation = apply_join_dependency.group(*primary_key_array)
    return relation.ids
  end

  columns = arel_columns(primary_key_array)
  relation = spawn
  relation.select_values = columns

  result = if relation.where_clause.contradiction?
    ActiveRecord::Result.empty
  else
    skip_query_cache_if_necessary do
      klass.connection.select_all(relation, "#{klass.name} Ids", async: @async)
    end
  end

  result.then { |result| type_cast_pluck_values(result, columns) }
end

Возвращает идентификаторы базовой модели для отношения, используя первичный ключ таблицы.

Person.ids # SELECT people.id FROM people
Person.joins(:companies).ids # SELECT people.id FROM people INNER JOIN companies ON companies.id = people.company_id

maximum(column_name) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 136
def maximum(column_name)
  calculate(:maximum, column_name)
end

Вычисляет максимальное значение в заданном столбце. Значение возвращается с тем же типом данных, что и столбец, или nil , если нет строк. См. calculate для примеров с параметрами.

Person.maximum(:age) # => 93

minimum(column_name) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 121
def minimum(column_name)
  calculate(:minimum, column_name)
end

Вычисляет минимальное значение в заданном столбце. Значение возвращается с тем же типом данных, что и столбец, или nil , если нет строк. См. calculate для примеров с параметрами.

Person.minimum(:age) # => 7

pick(*column_names) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 315
def pick(*column_names)
  if loaded? && all_attributes?(column_names)
    result = records.pick(*column_names)
    return @async ? Promise::Complete.new(result) : result
  end

  limit(1).pluck(*column_names).then(&:first)
end

Выбирает значение(я) из указанного(ых) столбца(ов) в текущем отношении. Это сокращение для relation.limit(1).pluck(*column_names).first, и оно в первую очередь полезно, когда у вас есть отношение, уже суженное до одной строки.

Как и pluck, pick будет загружать только фактическое значение, а не весь объект записи, поэтому это также более эффективно. Значение, как и при использовании pluck, типизируется типом столбца.

Person.where(id: 1).pick(:name)
# SELECT people.name FROM people WHERE id = 1 LIMIT 1
# => 'David'

Person.where(id: 1).pick(:name, :email_address)
# SELECT people.name, people.email_address FROM people WHERE id = 1 LIMIT 1
# => [ 'David', 'david@loudthinking.com' ]

END_OF_DOCUMENT_MARKER

pluck(*column_names) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 262
def pluck(*column_names)
  return [] if @none

  if loaded? && all_attributes?(column_names)
    result = records.pluck(*column_names)
    if @async
      return Promise::Complete.new(result)
    else
      return result
    end
  end

  if has_include?(column_names.first)
    relation = apply_join_dependency
    relation.pluck(*column_names)
  else
    klass.disallow_raw_sql!(column_names.flatten)
    columns = arel_columns(column_names)
    relation = spawn
    relation.select_values = columns
    result = skip_query_cache_if_necessary do
      if where_clause.contradiction?
        ActiveRecord::Result.empty(async: @async)
      else
        klass.connection.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
      end
    end
    result.then do |result|
      type_cast_pluck_values(result, columns)
    end
  end
end

Используйте pluck в качестве сокращения для выбора одного или нескольких атрибутов без загрузки всего объекта записи за строку.

Person.pluck(:name)

вместо

Person.all.map(&:name)

Pluck возвращает Array значений атрибутов, приведённых к типу, соответствующему названию столбца, если это возможно. Выборка SQL-фрагмента возвращает значения String по умолчанию.

Person.pluck(:name)
# SELECT people.name FROM people
# => ['David', 'Jeremy', 'Jose']

Person.pluck(:id, :name)
# SELECT people.id, people.name FROM people
# => [[1, 'David'], [2, 'Jeremy'], [3, 'Jose']]

Person.distinct.pluck(: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(Arel.sql('DATEDIFF(updated_at, created_at)'))
# SELECT DATEDIFF(updated_at, created_at) FROM people
# => ['0', '27761', '173']

См. также ids.

sum(initial_value_or_column = 0, &block) Показать исходный код

# File activerecord/lib/active_record/relation/calculations.rb, line 151
def sum(initial_value_or_column = 0, &block)
  if block_given?
    map(&block).sum(initial_value_or_column)
  else
    calculate(:sum, initial_value_or_column)
  end
end

Вычисляет сумму значений в заданном столбце. Значение возвращается с тем же типом данных, что и столбец, 0 если нет строк. См. calculate для примеров с параметрами.

Person.sum(:age) # => 4562