Record casuale in ActiveRecord

Ho bisogno di ottenere un record casuale da una tabella tramite ActiveRecord. Ho seguito l'esempio di Jamis Buck del 2006 .

Tuttavia, ho anche trovato un altro modo tramite una ricerca di Google (impossibile attribuire un link a causa delle restrizioni dei nuovi utenti):

 rand_id = rand(Model.count)
 rand_record = Model.first(:conditions => ["id >= ?", rand_id])

Sono curioso di sapere come hanno fatto gli altri qui o se qualcuno sa in che modo sarebbe più efficiente.

Non ho trovato il modo ideale per farlo senza almeno due domande.

Quanto segue utilizza un numero generato casualmente (fino al conteggio dei record correnti) come offset .

offset = rand(Model.count)

# Rails 4
rand_record = Model.offset(offset).first

# Rails 3
rand_record = Model.first(:offset => offset)

Ad essere sincero, ho appena usato ORDER BY RAND () o RANDOM () (a seconda del database). Non è un problema di prestazioni se non si dispone di un problema di prestazioni.

Rotaie 6

Come affermato da Jason nei commenti, in Rails 6 non sono ammessi argomenti senza attributi . Devi racchiudere il valore in Arel.sql()un'istruzione.

Model.order(Arel.sql('RANDOM()')).first

Rotaie 5, 4

In Rails 4 e 5 , usando Postgresql o SQLite , usando RANDOM():

Model.order('RANDOM()').first

Presumibilmente lo stesso funzionerebbe con MySQLRAND()

Model.order('RAND()').first

Questo è circa 2,5 volte più veloce dell'approccio nella risposta accettata .

Avvertenza : è lento per set di dati di grandi dimensioni con milioni di record, quindi potresti voler aggiungere una limitclausola.

Il codice di esempio inizierà a comportarsi in modo non corretto una volta eliminati i record (favorirà ingiustamente gli elementi con ID inferiori)

Probabilmente stai meglio usando i metodi casuali all'interno del tuo database. Questi variano a seconda del DB che stai usando, ma: order => "RAND ()" funziona per mysql e: order => "RANDOM ()" funziona per postgres

Model.first(:order => "RANDOM()") # postgres example

Benchmark di questi due metodi su MySQL 5.1.49, Ruby 1.9.2p180 su una tabella di prodotti con + 5 milioni di record:

def random1
  rand_id = rand(Product.count)
  rand_record = Product.first(:conditions => [ "id >= ?", rand_id])
end

def random2
  if (c = Product.count) != 0
    Product.find(:first, :offset =>rand(c))
  end
end

n = 10
Benchmark.bm(7) do |x|
  x.report("next id:") { n.times {|i| random1 } }
  x.report("offset:")  { n.times {|i| random2 } }
end


             user     system      total        real
next id:  0.040000   0.000000   0.040000 (  0.225149)
offset :  0.020000   0.000000   0.020000 ( 35.234383)

L'offset in MySQL sembra essere molto più lento.

EDIT Ho anche provato

Product.first(:order => "RAND()")

Ma ho dovuto ucciderlo dopo ~ 60 secondi. MySQL era "Copia su tabella tmp su disco". Non funzionerà.

Non deve essere così difficile.

ids = Model.pluck(:id)
random_model = Model.find(ids.sample)

pluckrestituisce una matrice di tutti gli ID nella tabella. Il samplemetodo sull'array restituisce un ID casuale dall'array.

Ciò dovrebbe funzionare bene, con uguale probabilità di selezione e supporto per le tabelle con righe eliminate. Puoi persino mescolarlo con vincoli.

User.where(favorite_day: "Friday").pluck(:id)

E quindi scegliere un utente casuale a cui piacciono i venerdì piuttosto che qualsiasi altro utente.

Non è consigliabile utilizzare questa soluzione, ma se per qualche motivo si desidera davvero selezionare casualmente un record mentre si esegue solo una query del database, è possibile utilizzare il samplemetodo della classe Array Ruby , che consente di selezionare un elemento casuale da un array.

Model.all.sample

Questo metodo richiede solo query di database, ma è significativamente più lento rispetto a alternative come quelle Model.offset(rand(Model.count)).firstche richiedono due query di database, sebbene quest'ultima sia ancora preferita.

Ho fatto un gioiello di Rails 3 per gestire questo:

https://github.com/spilliton/randumb

Ti permette di fare cose come questa:

Model.where(:column => "value").random(10)

Lo uso così spesso dalla console che estendo ActiveRecord in un inizializzatore - esempio di Rails 4:

class ActiveRecord::Base
  def self.random
    self.limit(1).offset(rand(self.count)).first
  end
end

Posso quindi chiamare Foo.randomper riportare un record casuale.

Una query in Postgres:

User.order('RANDOM()').limit(3).to_sql # Postgres example
=> "SELECT "users".* FROM "users" ORDER BY RANDOM() LIMIT 3"

Utilizzando un offset, due query:

offset = rand(User.count) # returns an integer between 0 and (User.count - 1)
Model.offset(offset).limit(1)

Leggere tutto ciò non mi ha dato molta fiducia su quale di questi avrebbe funzionato meglio nella mia situazione particolare con Rails 5 e MySQL / Maria 5.5. Quindi ho testato alcune delle risposte su ~ 65000 record e ho due take away:

1. RAND () con a limitè un chiaro vincitore.
2. Non usare pluck+ sample.

def random1
  Model.find(rand((Model.last.id + 1)))
end

def random2
  Model.order("RAND()").limit(1)
end

def random3
  Model.pluck(:id).sample
end

n = 100
Benchmark.bm(7) do |x|
  x.report("find:")    { n.times {|i| random1 } }
  x.report("order:")   { n.times {|i| random2 } }
  x.report("pluck:")   { n.times {|i| random3 } }
end

              user     system      total        real
find:     0.090000   0.000000   0.090000 (  0.127585)
order:    0.000000   0.000000   0.000000 (  0.002095)
pluck:    6.150000   0.000000   6.150000 (  8.292074)

Questa risposta sintetizza, convalida e aggiorna la risposta di Mohamed , così come il commento di Nami WANG sullo stesso e il commento di Florian Pilz sulla risposta accettata - inviaci voti!

È possibile utilizzare il Arraymetodo sample, il metodo samplerestituisce un oggetto casuale da un array, per poterlo utilizzare è sufficiente eseguire in una semplice ActiveRecordquery che restituisce una raccolta, ad esempio:

User.all.sample

restituirà qualcosa del genere:

#<User id: 25, name: "John Doe", email: "admin@example.info", created_at: "2018-04-16 19:31:12", updated_at: "2018-04-16 19:31:12">

Consiglio vivamente questo gioiello per i record casuali, che è appositamente progettato per la tabella con molte righe di dati:

https://github.com/haopingfan/quick_random_records

Tutte le altre risposte funzionano male con database di grandi dimensioni, tranne questa gemma:

1. quick_random_records costa solo 4.6mstotalmente.

2. il User.order('RAND()').limit(10)costo 733.0ms.

3. l' offsetapproccio con risposta accettata costa 245.4mstotalmente.

4. il User.all.sample(10)costo di avvicinamento 573.4ms.

Nota: il mio tavolo ha solo 120.000 utenti. Più record hai, più enorme sarà la differenza di prestazioni.

Se è necessario selezionare alcuni risultati casuali nell'ambito specificato :

scope :male_names, -> { where(sex: 'm') }
number_of_results = 10

rand = Names.male_names.pluck(:id).sample(number_of_results)
Names.where(id: rand)

Il metodo Ruby per selezionare casualmente un oggetto da un elenco è sample. Volendo creare un efficiente sampleper ActiveRecord e sulla base delle risposte precedenti, ho usato:

module ActiveRecord
  class Base
    def self.sample
      offset(rand(size)).first
    end
  end
end

Lo inserisco lib/ext/sample.rbe poi lo carico con questo in config/initializers/monkey_patches.rb:

Dir[Rails.root.join('lib/ext/*.rb')].each { |file| require file }

Questa sarà una query se la dimensione del modello è già memorizzata nella cache e due in caso contrario.

Rails 4.2 e Oracle :

Per Oracle puoi impostare un ambito sul tuo Modello in questo modo:

scope :random_order, -> {order('DBMS_RANDOM.RANDOM')}

o

scope :random_order, -> {order('DBMS_RANDOM.VALUE')}

E poi per un campione chiamalo così:

Model.random_order.take(10)

o

Model.random_order.limit(5)

ovviamente puoi anche effettuare un ordine senza un ambito come questo:

Model.all.order('DBMS_RANDOM.RANDOM') # or DBMS_RANDOM.VALUE respectively

Per il database MySQL provare prima: Model.order ("RAND ()")

Se stai usando PostgreSQL 9.5+, puoi trarre vantaggio dalla TABLESAMPLEselezione di un record casuale.

I due metodi di campionamento predefiniti ( SYSTEMe BERNOULLI) richiedono che si specifichi il numero di righe da restituire come percentuale del numero totale di righe nella tabella.

-- Fetch 10% of the rows in the customers table.
SELECT * FROM customers TABLESAMPLE BERNOULLI(10);

Ciò richiede la conoscenza della quantità di record nella tabella per selezionare la percentuale appropriata, che potrebbe non essere facile da trovare rapidamente. Fortunatamente, c'è il tsm_system_rowsmodulo che ti consente di specificare il numero di righe da restituire direttamente.

CREATE EXTENSION tsm_system_rows;

-- Fetch a single row from the customers table.
SELECT * FROM customers TABLESAMPLE SYSTEM_ROWS(1);

Per usarlo all'interno di ActiveRecord, prima abilita l'estensione all'interno di una migrazione:

class EnableTsmSystemRowsExtension < ActiveRecord::Migration[5.0]
  def change
    enable_extension "tsm_system_rows"
  end
end

Quindi modificare la fromclausola della query:

customer = Customer.from("customers TABLESAMPLE SYSTEM_ROWS(1)").first

Non so se il SYSTEM_ROWSmetodo di campionamento sarà del tutto casuale o se restituirà solo la prima riga da una pagina casuale.

La maggior parte di queste informazioni sono state tratte da un post sul blog 2ndQuadrant scritto da Gulcin Yildirim .

Dopo aver visto così tante risposte ho deciso di confrontarle tutte sul mio database PostgreSQL (9.6.3). Uso un tavolo più piccolo di 100.000 e mi sono sbarazzato di Model.order ("RANDOM ()"). Innanzitutto poiché era già due ordini di grandezza più lento.

Usando una tabella con 2.500.000 voci con 10 colonne, il vincitore era il metodo pluck quasi 8 volte più veloce del runner up (offset. Ho eseguito questo solo su un server locale in modo che il numero potesse essere gonfiato, ma è abbastanza grande che il pluck Il metodo è quello che finirò per usare. Vale anche la pena notare che ciò potrebbe causare problemi se si colgono più di 1 risultato alla volta poiché ognuno di questi sarà unico, ovvero meno casuale.

Pluck vince correndo 100 volte sul mio tavolo da 25.000.000 di righe Modifica: in realtà questa volta include il pluck nel loop se lo estraggo corre veloce quanto una semplice iterazione sull'ID. Però; occupa una buona quantità di RAM.

RandomModel                 user     system      total        real
Model.find_by(id: i)       0.050000   0.010000   0.060000 (  0.059878)
Model.offset(rand(offset)) 0.030000   0.000000   0.030000 ( 55.282410)
Model.find(ids.sample)     6.450000   0.050000   6.500000 (  7.902458)

Ecco i dati che vengono eseguiti 2000 volte sulla mia tabella di 100.000 righe per escludere casualmente

RandomModel       user     system      total        real
find_by:iterate  0.010000   0.000000   0.010000 (  0.006973)
offset           0.000000   0.000000   0.000000 (  0.132614)
"RANDOM()"       0.000000   0.000000   0.000000 ( 24.645371)
pluck            0.110000   0.020000   0.130000 (  0.175932)

Domanda molto vecchia ma con:

rand_record = Model.all.shuffle

Hai una matrice di record, ordinata per ordine casuale. Non sono necessarie gemme o script.

Se vuoi un record:

rand_record = Model.all.shuffle.first

Sono nuovo di zecca per RoR ma ho fatto in modo che funzioni per me:

 def random
    @cards = Card.all.sort_by { rand }
 end

Viene da:

Come ordinare casualmente (rimescolare) un array in Ruby?

Cosa sta per fare:

rand_record = Model.find(Model.pluck(:id).sample)

Per me è molto chiaro

Provo questo esempio di Sam sulla mia app usando le rotaie 4.2.8 di Benchmark (ho messo 1..Category.count per casuale, perché se il casuale prende uno 0 produrrà un errore (ActiveRecord :: RecordNotFound: Impossibile trovare Categoria con "id" = 0)) e la mia era:

 def random1
2.4.1 :071?>   Category.find(rand(1..Category.count))
2.4.1 :072?>   end
 => :random1
2.4.1 :073 > def random2
2.4.1 :074?>    Category.offset(rand(1..Category.count))
2.4.1 :075?>   end
 => :random2
2.4.1 :076 > def random3
2.4.1 :077?>   Category.offset(rand(1..Category.count)).limit(rand(1..3))
2.4.1 :078?>   end
 => :random3
2.4.1 :079 > def random4
2.4.1 :080?>    Category.pluck(rand(1..Category.count))
2.4.1 :081?>
2.4.1 :082 >     end
 => :random4
2.4.1 :083 > n = 100
 => 100
2.4.1 :084 > Benchmark.bm(7) do |x|
2.4.1 :085 >     x.report("find") { n.times {|i| random1 } }
2.4.1 :086?>   x.report("offset") { n.times {|i| random2 } }
2.4.1 :087?>   x.report("offset_limit") { n.times {|i| random3 } }
2.4.1 :088?>   x.report("pluck") { n.times {|i| random4 } }
2.4.1 :089?>   end

                  user      system      total     real
find            0.070000   0.010000   0.080000 (0.118553)
offset          0.040000   0.010000   0.050000 (0.059276)
offset_limit    0.050000   0.000000   0.050000 (0.060849)
pluck           0.070000   0.020000   0.090000 (0.099065)

.order('RANDOM()').limit(limit)sembra pulito ma è lento per le tabelle di grandi dimensioni perché deve recuperare e ordinare tutte le righe anche se limitè 1 (internamente nel database ma non in Rails). Non sono sicuro di MySQL, ma questo succede in Postgres. Altre spiegazioni qui e qui .

Una soluzione per tavoli di grandi dimensioni è .from("products TABLESAMPLE SYSTEM(0.5)")dove 0.5significa 0.5%. Tuttavia, trovo che questa soluzione sia ancora lenta se si hanno WHEREcondizioni che filtrano molte righe. Immagino sia perché TABLESAMPLE SYSTEM(0.5)hai recuperato tutte le righe primaWHERE che si applichino le condizioni.

Un'altra soluzione per tavoli di grandi dimensioni (ma non molto casuali) è:

products_scope.limit(sample_size).sample(limit)

dove sample_sizepuò essere 100(ma non troppo grande, altrimenti è lento e consuma molta memoria) e limitpuò essere 1. Nota che sebbene sia veloce ma non è davvero casuale, è casuale sample_sizesolo all'interno dei record.

PS: I risultati del benchmark nelle risposte sopra non sono affidabili (almeno in Postgres) perché alcune query DB eseguite alla seconda volta possono essere significativamente più veloci rispetto all'esecuzione alla prima volta, grazie alla cache DB. E sfortunatamente non esiste un modo semplice per disabilitare la cache in Postgres per rendere affidabili questi benchmark.

Oltre all'utilizzo RANDOM(), puoi anche inserirlo in un ambito:

class Thing
  scope :random, -> (limit = 1) {
    order('RANDOM()').
    limit(limit)
  }
end

Oppure, se non lo desideri come un ambito, gettalo in un metodo di classe. Ora Thing.randomfunziona insieme a Thing.random(n).

A seconda del significato di "casuale" e di ciò che desideri effettivamente fare, take potrebbe essere sufficiente.

Per "significato" di casuale intendo:

• Intendi darmi qualche elemento che non mi interessa che sia la posizione? allora è abbastanza.
• Ora, se vuoi dire "dammi qualsiasi elemento con una buona probabilità che esperimenti ripetuti mi daranno elementi diversi dall'insieme", allora forza la "Fortuna" con uno dei metodi menzionati nelle altre risposte.

Ad esempio, per i test, i dati di esempio potrebbero essere stati creati casualmente in ogni caso, quindi takeè più che sufficiente e, a dire il vero, anche first.

https://guides.rubyonrails.org/active_record_querying.html#take