Propre façon de trouver ActiveRecord objets par id dans l'ordre spécifié

Basé sur mon commentaire précédent à Jeroen van Dijk, vous pouvez le faire plus efficacement et en deux lignes à l'aide de 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]}

Pour la référence ici est la référence que j'ai utilisé

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

Maintenant l'autre

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

Mise à jour

Vous pouvez le faire dans la plupart à l'aide de l'ordre et de cas relevés, ici est une méthode de classe que vous pouvez utiliser.

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]

Un portable solution serait d'utiliser un SQL instruction de CAS dans votre COMMANDE PAR. Vous pouvez utiliser à peu près n'importe quelle expression dans un ORDRE et un CAS peut être utilisé comme un inline table de recherche. Par exemple, le SQL, vous êtes après ressemblerait à ceci:

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

C'est assez facile de générer avec un peu de Ruby:

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

Ci-dessus suppose que vous travaillez avec des chiffres ou certains autres valeurs sûres dans ids; si ce n'est pas le cas, alors vous voulez les utiliser connexion.citation ou l'un des ActiveRecord SQL désinfectant méthodes de bien indiquer votre ids.

Puis utilisez le order chaîne en tant que votre commande de condition:

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

ou dans le monde moderne:

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

C'est un peu verbeux, mais il devrait fonctionner de la même avec toute la base de données SQL et il n'est pas difficile de cacher la laideur.

Justin Weiss a écrit un article de blog sur ce problème juste il y a deux jours.

Il semble être une bonne approche pour raconter la base de données sur l'ordre de préférence et de charger tous les enregistrements triés dans l'ordre directement à partir de la base de données. Exemple de son article du blog:

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

Qui permet d'écrire:

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

L'autre (probablement la plus efficace) de manière à faire en 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] }

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

C'est probablement la façon la plus simple, en supposant que vous n'avez pas trop d'objets à trouver, car il nécessite un voyage à la base de données pour chaque id.