Чистый способ найти объекты ActiveRecord по id в указанном порядке

Question

Я хочу получить массив объектов ActiveRecord по массиву идентификаторов.

Я предположил, что

Object.find([5,2,3])

Возвращает массив с объектом 5, объектом 2, затем объектом 3 в этом порядке, но вместо этого я получаю массив, упорядоченный как объект 2, объект 3 и затем объект 5.

ActiveRecord Base API метода поиска упоминает, что вы не должны ожидать его в указанном порядке (другая документация не дает этого предупреждения).

Одно потенциальное решение было дано в Найти по массиву идентификаторов в том же порядке? , но опция порядка не подходит для SQLite.

Я могу написать какой-нибудь код ruby ​​для самостоятельной сортировки объектов (либо несколько простых и плохо масштабируемых, либо лучше масштабируемых и более сложных), но есть ли A Better Way?

Answer 1

Дело не в том, что MySQL и другие БД сортируют вещи самостоятельно, а в том, что они не сортируют их. Когда вы вызываете Model.find([5, 2, 3]), сгенерированный SQL выглядит примерно так:

SELECT * FROM models WHERE models.id IN (5, 2, 3)

Это не указывает порядок, только набор записей, которые вы хотите вернуть. Оказывается, что обычно MySQL будет возвращать строки базы данных в порядке 'id', но это не гарантируется.

Единственный способ заставить базу данных возвращать записи в гарантированном порядке - добавить условие заказа. Если ваши записи всегда будут возвращаться в определенном порядке, то вы можете добавить столбец сортировки в базу данных и сделать Model.find([5, 2, 3], :order => 'sort_column'). Если это не так, вам придется выполнить сортировку в коде:

ids = [5, 2, 3]
records = Model.find(ids)
sorted_records = ids.collect {|id| records.detect {|x| x.id == id}} 

Answer 2

Исходя из моего предыдущего комментария к Йерун ван Дейк, вы можете сделать это более эффективно и в две строки, используя each_with_object

result_hash = Model.find(ids).each_with_object({}) {|result,result_hash| result_hash[result.id] = result }
ids.map {|id| result_hash[id]}

Для справки вот эталонный тест, который я использовал

ids = [5,3,1,4,11,13,10]
results = Model.find(ids)

Benchmark.measure do 
  100000.times do 
    result_hash = results.each_with_object({}) {|result,result_hash| result_hash[result.id] = result }
    ids.map {|id| result_hash[id]}
  end
end.real
#=>  4.45757484436035 seconds

Теперь другой

ids = [5,3,1,4,11,13,10]
results = Model.find(ids)
Benchmark.measure do 
  100000.times do 
    ids.collect {|id| results.detect {|result| result.id == id}}
  end
end.real
# => 6.10875988006592

Обновление

Вы можете сделать это в большинстве случаев, используя операторы order и case, вот метод класса, который вы можете использовать.

def self.order_by_ids(ids)
  order_by = ["case"]
  ids.each_with_index.map do |id, index|
    order_by << "WHEN id='#{id}' THEN #{index}"
  end
  order_by << "end"
  order(order_by.join(" "))
end

#   User.where(:id => [3,2,1]).order_by_ids([3,2,1]).map(&:id) 
#   #=> [3,2,1]

Answer 3

Переносимым решением было бы использование оператора SQL CASE в вашем ORDER BY. Вы можете использовать практически любое выражение в ORDER BY, а CASE можно использовать как встроенную таблицу поиска. Например, SQL, который вы ищете, будет выглядеть так:

select ...
order by
    case id
    when 5 then 0
    when 2 then 1
    when 3 then 2
    end

Это довольно легко сгенерировать с небольшим количеством Ruby:

ids = [5, 2, 3]
order = 'case id ' + (0 .. ids.length).map { |i| "when #{ids[i]} then #{i}" }.join(' ') + ' end'

Выше предполагается, что вы работаете с числами или некоторыми другими безопасными значениями в ids; если это не так, вы можете использовать connection.quote или один из ActiveRecord SQL-методов дезинфекции , чтобы правильно заключить в кавычки ids.

Затем используйте строку order в качестве условия заказа:

Object.find(ids, :order => order)

или в современном мире:

Object.where(:id => ids).order(order)

Это немного многословно, но оно должно работать одинаково с любой базой данных SQL, и не так сложно скрыть уродство.

Answer 4

Очевидно, MySQL и другие системы управления БД сортируют вещи самостоятельно. Я думаю, что вы можете обойти это, делая:

ids = [5,2,3]
@things = Object.find( ids, :order => "field(id,#{ids.join(',')})" )

Answer 5

Когда я ответил здесь , я только что выпустил гем ( order_as_specified ), который позволяет вам выполнять упорядочивание собственного SQL следующим образом:

Object.where(id: [5, 2, 3]).order_as_specified(id: [5, 2, 3])

Только что протестировано и работает в SQLite.

Answer 6

Джастин Вайс написал статью в блоге об этой проблеме всего два дня назад.

Кажется, это хороший способ сообщить базе данных о предпочтительном порядке и загрузить все записи, отсортированные в этом порядке, непосредственно из базы данных. Пример из его статьи блога :

# in config/initializers/find_by_ordered_ids.rb
module FindByOrderedIdsActiveRecordExtension
  extend ActiveSupport::Concern
  module ClassMethods
    def find_ordered(ids)
      order_clause = "CASE id "
      ids.each_with_index do |id, index|
        order_clause << "WHEN #{id} THEN #{index} "
      end
      order_clause << "ELSE #{ids.length} END"
      where(id: ids).order(order_clause)
    end
  end
end

ActiveRecord::Base.include(FindByOrderedIdsActiveRecordExtension)

Это позволяет вам написать:

Object.find_ordered([2, 1, 3]) # => [2, 1, 3]

Answer 7

Вот как выглядит метод с производительностью (поиск по хэшу, а не поиск по O (n), как при обнаружении!):

def find_ordered(model, ids)
  model.find(ids).map{|o| [o.id, o]}.to_h.values_at(*ids)
end

# We get:
ids = [3, 3, 2, 1, 3]
Model.find(ids).map(:id)          == [1, 2, 3]
find_ordered(Model, ids).map(:id) == ids

Answer 8

Вот самая простая вещь, которую я мог придумать:

ids = [200, 107, 247, 189]
results = ModelObject.find(ids).group_by(&:id)
sorted_results = ids.map {|id| results[id].first }

Answer 9

Другой (возможно, более эффективный) способ сделать это в Ruby:

ids = [5, 2, 3]
records_by_id = Model.find(ids).inject({}) do |result, record| 
  result[record.id] = record
  result
end
sorted_records = ids.map {|id| records_by_id[id] }

Answer 10

@things = [5,2,3].map{|id| Object.find(id)}

Это, вероятно, самый простой способ, при условии, что у вас не так много объектов для поиска, поскольку для каждого идентификатора требуется поездка в базу данных.