ActiveRecord.find (array_of_ids), préservation de l'ordre

Lorsque vous faites Something.find(array_of_ids)dans Rails, l'ordre du tableau résultant ne dépend pas de l'ordre de array_of_ids.

Existe-t-il un moyen de rechercher et de conserver la commande?

ATM Je trie manuellement les enregistrements en fonction de l'ordre des ID, mais c'est un peu nul.

UPD: s'il est possible de spécifier l'ordre en utilisant le :orderparamètre et une sorte de clause SQL, alors comment?

La réponse est pour mysql uniquement

Il y a une fonction dans mysql appelée FIELD ()

Voici comment vous pouvez l'utiliser dans .find ():

>> ids = [100, 1, 6]
=> [100, 1, 6]

>> WordDocument.find(ids).collect(&:id)
=> [1, 6, 100]

>> WordDocument.find(ids, :order => "field(id, #{ids.join(',')})")
=> [100, 1, 6]

For new Version
>> WordDocument.where(id: ids).order("field(id, #{ids.join ','})")

Mise à jour: cela sera supprimé dans le code source de Rails 6.1 Rails

Curieusement, personne n'a suggéré quelque chose comme ceci:

index = Something.find(array_of_ids).group_by(&:id)
array_of_ids.map { |i| index[i].first }

Aussi efficace que possible, en plus de laisser le backend SQL le faire.

Edit: Pour améliorer ma propre réponse, vous pouvez également le faire comme ceci:

Something.find(array_of_ids).index_by(&:id).slice(*array_of_ids).values

#index_byet #slicesont des ajouts très pratiques dans ActiveSupport pour les tableaux et les hachages respectivement.

Comme Mike Woodhouse l'a déclaré dans sa réponse , cela se produit parce que, sous le capot, Rails utilise une requête SQL avec un WHERE id IN... clausepour récupérer tous les enregistrements en une seule requête. C'est plus rapide que de récupérer chaque identifiant individuellement, mais comme vous l'avez remarqué, cela ne préserve pas l'ordre des enregistrements que vous récupérez.

Pour résoudre ce problème, vous pouvez trier les enregistrements au niveau de l'application en fonction de la liste d'origine des ID que vous avez utilisés lors de la recherche de l'enregistrement.

Sur la base des nombreuses excellentes réponses pour trier un tableau en fonction des éléments d'un autre tableau , je recommande la solution suivante:

Something.find(array_of_ids).sort_by{|thing| array_of_ids.index thing.id}

Ou si vous avez besoin de quelque chose d'un peu plus rapide (mais sans doute un peu moins lisible), vous pouvez le faire:

Something.find(array_of_ids).index_by(&:id).values_at(*array_of_ids)

Cela semble fonctionner pour postgresql ( source ) - et renvoie une relation ActiveRecord

class Something < ActiveRecrd::Base

  scope :for_ids_with_order, ->(ids) {
    order = sanitize_sql_array(
      ["position((',' || id::text || ',') in ?)", ids.join(',') + ',']
    )
    where(:id => ids).order(order)
  }    
end

# usage:
Something.for_ids_with_order([1, 3, 2])

peut également être étendu à d'autres colonnes, par exemple pour name colonne, utilisez position(name::text in ?)...

Comme je l'ai répondu ici , je viens de publier un gem ( order_as_specified ) qui vous permet de faire un ordre SQL natif comme ceci:

Something.find(array_of_ids).order_as_specified(id: array_of_ids)

Autant que j'ai pu tester, cela fonctionne de manière native dans tous les SGBDR, et il renvoie une relation ActiveRecord qui peut être chaînée.

Pas possible dans SQL qui fonctionnerait dans tous les cas, malheureusement, vous auriez soit besoin d'écrire des recherches uniques pour chaque enregistrement, soit de commander en ruby, bien qu'il existe probablement un moyen de le faire fonctionner en utilisant des techniques propriétaires:

Premier exemple:

sorted = arr.inject([]){|res, val| res << Model.find(val)}

TRÈS INEFFICACE

Deuxième exemple:

unsorted = Model.find(arr)
sorted = arr.inject([]){|res, val| res << unsorted.detect {|u| u.id == val}}

La réponse @Gunchars est excellente, mais elle ne fonctionne pas directement dans Rails 2.3 car la classe Hash n'est pas ordonnée. Une solution de contournement simple consiste à étendre la classe Enumerable ' index_bypour utiliser la classe OrderedHash:

module Enumerable
  def index_by_with_ordered_hash
    inject(ActiveSupport::OrderedHash.new) do |accum, elem|
      accum[yield(elem)] = elem
      accum
    end
  end
  alias_method_chain :index_by, :ordered_hash
end

L'approche de @Gunchars fonctionnera maintenant

Something.find(array_of_ids).index_by(&:id).slice(*array_of_ids).values

Prime

module ActiveRecord
  class Base
    def self.find_with_relevance(array_of_ids)
      array_of_ids = Array(array_of_ids) unless array_of_ids.is_a?(Array)
      self.find(array_of_ids).index_by(&:id).slice(*array_of_ids).values
    end
  end
end

ensuite

Something.find_with_relevance(array_of_ids)

En supposant des Model.pluck(:id)retours [1,2,3,4]et que vous voulez l'ordre de[2,4,1,3]

Le concept consiste à utiliser la ORDER BY CASE WHENclause SQL. Par exemple:

SELECT * FROM colors
  ORDER BY
  CASE
    WHEN code='blue' THEN 1
    WHEN code='yellow' THEN 2
    WHEN code='green' THEN 3
    WHEN code='red' THEN 4
    ELSE 5
  END, name;

Dans Rails, vous pouvez y parvenir en ayant une méthode publique dans votre modèle pour construire une structure similaire:

def self.order_by_ids(ids)
  if ids.present?
    order_by = ["CASE"]
    ids.each_with_index do |id, index|
      order_by << "WHEN id='#{id}' THEN #{index}"
    end
    order_by << "END"
    order(order_by.join(" "))
  end
else
  all # If no ids, just return all
end

Alors fais:

ordered_by_ids = [2,4,1,3]

results = Model.where(id: ordered_by_ids).order_by_ids(ordered_by_ids)

results.class # Model::ActiveRecord_Relation < ActiveRecord::Relation

La bonne chose à ce sujet. Les résultats sont renvoyés comme des relations ActiveRecord (vous permettant d'utiliser des méthodes telles que last, count, where, pluck, etc.)

Il y a une gemme find_with_order qui vous permet de le faire efficacement en utilisant une requête SQL native.

Et il prend en charge à la fois Mysqlet PostgreSQL.

Par exemple:

Something.find_with_order(array_of_ids)

Si vous voulez une relation:

Something.where_with_order(:id, array_of_ids)

Sous le capot, findavec un tableau d'id générera SELECTune WHERE id IN...clause with a , ce qui devrait être plus efficace que de parcourir les ID.

La requête est donc satisfaite en un seul voyage vers la base de données, mais les SELECTs sans ORDER BYclauses ne sont pas triées. ActiveRecord comprend cela, nous développons donc notre findcomme suit:

Something.find(array_of_ids, :order => 'id')

Si l'ordre des identifiants dans votre tableau est arbitraire et significatif (c'est-à-dire que vous voulez que l'ordre des lignes renvoyées corresponde à votre tableau indépendamment de la séquence d'identifiants qu'il contient), je pense que vous seriez le meilleur serveur en post-traitant les résultats dans code - vous pourriez construire une :orderclause mais ce serait diaboliquement compliqué et pas du tout révélateur d'intention.

Bien que je ne le vois pas mentionné nulle part dans un CHANGELOG, il semble que cette fonctionnalité ait été modifiée avec la sortie de la version 5.2.0.

Ici, commettez la mise à jour des documents étiquetés avec 5.2.0Cependant, il semble avoir également été rétroporté dans la version 5.0.

En référence à la réponse ici

Object.where(id: ids).order("position(id::text in '#{ids.join(',')}')") fonctionne pour Postgresql.

Il y a une clause order dans find (: order => '...') qui fait cela lors de la récupération des enregistrements. Vous pouvez également obtenir de l'aide d'ici.

texte du lien