ActiveRecord.find (array_of_ids), mantenendo l'ordine

Quando lo fai Something.find(array_of_ids) in Rails, l'ordine dell'array risultante non dipende dall'ordine di array_of_ids.

C'è un modo per trovare e preservare l'ordine?

ATM Ordino manualmente i record in base all'ordine degli ID, ma è un po 'noioso.

UPD: se è possibile specificare l'ordine utilizzando il :orderparametro e una sorta di clausola SQL, allora come?

La risposta è solo per mysql

C'è una funzione in mysql chiamata FIELD ()

Ecco come potresti usarlo in .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 ','})")

Aggiornamento: verrà rimosso nel codice sorgente di Rails 6.1 Rails

Stranamente, nessuno ha suggerito qualcosa del genere:

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

Il più efficiente possibile oltre a lasciare che il backend SQL lo faccia.

Modifica: per migliorare la mia risposta, puoi anche farlo in questo modo:

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

#index_bye #slicesono aggiunte piuttosto utili in ActiveSupport rispettivamente per array e hash.

Come affermato Mike Woodhouse nella sua risposta , ciò si verifica perché, sotto il cofano, Rails sta usando una query SQL con estensioneWHERE id IN... clause per recuperare tutti i record in una query. Questo è più veloce del recupero di ogni ID individualmente, ma come hai notato non conserva l'ordine dei record che stai recuperando.

Per risolvere questo problema, puoi ordinare i record a livello di applicazione in base all'elenco originale di ID che hai utilizzato durante la ricerca del record.

Basato sulle molte risposte eccellenti per ordinare un array in base agli elementi di un altro array , consiglio la seguente soluzione:

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

O se hai bisogno di qualcosa di un po 'più veloce (ma probabilmente un po' meno leggibile) potresti farlo:

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

Questo sembra funzionare per postgresql ( sorgente ) e restituisce una relazione 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])

può essere esteso anche ad altre colonne, ad esempio per la namecolonna, utilizzare position(name::text in ?)...

Come ho risposto qui , ho appena rilasciato una gemma ( order_as_specified ) che ti consente di eseguire l'ordinamento SQL nativo in questo modo:

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

Per quanto ho potuto testare, funziona in modo nativo in tutti gli RDBMS e restituisce una relazione ActiveRecord che può essere concatenata.

Non è possibile in SQL che funzioni in tutti i casi, sfortunatamente, dovresti scrivere singoli reperti per ogni record o ordinare in ruby, anche se probabilmente c'è un modo per farlo funzionare utilizzando tecniche proprietarie:

Primo esempio:

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

MOLTO INEFFICIENTE

Secondo esempio:

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

La risposta di @Gunchars è ottima, ma non funziona immediatamente in Rails 2.3 perché la classe Hash non è ordinata. Una soluzione semplice è estendere la classe Enumerable index_byper utilizzare 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

Ora l'approccio di @Gunchars funzionerà

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

Bonus

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

Poi

Something.find_with_relevance(array_of_ids)

Supponendo che i Model.pluck(:id)ritorni [1,2,3,4]e tu voglia l'ordine di[2,4,1,3]

Il concetto è quello di utilizzare la ORDER BY CASE WHENclausola SQL. Per esempio:

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;

In Rails, puoi ottenere questo risultato avendo un metodo pubblico nel tuo modello per costruire una struttura simile:

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

Quindi fa:

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 cosa buona di questo. I risultati vengono restituiti come ActiveRecord Relazioni (che consente di utilizzare metodi come last, count, where, pluck, ecc)

C'è una gemma find_with_order che ti consente di farlo in modo efficiente utilizzando una query SQL nativa.

E supporta sia Mysqle PostgreSQL.

Per esempio:

Something.find_with_order(array_of_ids)

Se vuoi una relazione:

Something.where_with_order(:id, array_of_ids)

Sotto il cofano, findcon un array di ID genererà un SELECTcon una WHERE id IN...clausola, che dovrebbe essere più efficiente del ciclo tra gli ID.

Quindi la richiesta viene soddisfatta in un viaggio nel database, ma le clausole SELECTsenza ORDER BYclausole non vengono ordinate. ActiveRecord lo capisce, quindi espandiamo il nostro findcome segue:

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

Se l'ordine degli ID nel tuo array è arbitrario e significativo (ovvero vuoi che l'ordine delle righe restituite corrisponda al tuo array indipendentemente dalla sequenza degli ID in esso contenuti), allora penso che saresti il ​​miglior server post-elaborando i risultati in codice: potresti creare una :orderclausola ma sarebbe diabolicamente complicata e non rivelerebbe affatto l'intenzione.

Sebbene non lo vedo menzionato da nessuna parte in un CHANGELOG, sembra che questa funzionalità sia stata modificata con il rilascio della versione5.2.0 .

Qui eseguire il commit dell'aggiornamento dei documenti contrassegnati con 5.2.0Tuttavia sembra che sia stato anche eseguito il backport nella versione 5.0.

Con riferimento alla risposta qui

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

C'è una clausola order in find (: order => '...') che lo fa durante il recupero dei record. Puoi ottenere aiuto anche da qui.

testo del collegamento