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

Question

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

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

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

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

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

Одно потенциальное решение было дано в Find by array of ids in the same order?, но опция заказа не подходит для SQLite.

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

Answer 1

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

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

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

Единственный способ получить базу данных для возврата записей в гарантированном порядке - это добавить предложение заказа. Если ваши записи всегда будут возвращены в определенном порядке, вы можете добавить столбец сортировки в db и сделать 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

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

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

Answer 3

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

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

Answer 4

Другой (вероятно, более эффективный) способ сделать это в 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 5

на основе моего предыдущего комментарий Йерун ван Дейк вы можете сделать это более эффективно и в двух линиях с использованием 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 

Update

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

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 6

Вот самое простое, что я мог придумать:

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

Answer 7

Портативное решение было бы использовать оператор CASE, SQL в ваш заказ. Вы можете использовать почти любое выражение в 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 sanitizer methods, чтобы правильно указать свой ids.

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

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

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

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

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

Answer 8

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

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

Просто протестирован и работает в SQLite.

Answer 9

Justin Weiss написал blog article about this problem всего два дня назад.

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

# 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 10

Вот производительный (хэш-поиска, а не O (п) поиск массива, как в детектировать!) Однострочник, а Метод:

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