Quindi, ho trovato diversi esempi per trovare un record casuale in Rails 2 - il metodo preferito sembra essere:

Thing.find :first, :offset => rand(Thing.count)

Essendo qualcosa di nuovo, non sono sicuro di come questo possa essere costruito usando la nuova sintassi find in Rails 3.

Allora, qual è il "Rails 3 Way" per trovare un disco casuale?

Thing.first(:order => "RANDOM()") # For MySQL :order => "RAND()", - thanx, @DanSingerman
# Rails 3
Thing.order("RANDOM()").first

o

Thing.first(:offset => rand(Thing.count))
# Rails 3
Thing.offset(rand(Thing.count)).first

In realtà, in Rails 3 funzioneranno tutti gli esempi. Ma usare l'ordine RANDOMè piuttosto lento per i tavoli più grandi ma più in stile sql

UPD. Puoi usare il seguente trucco su una colonna indicizzata (sintassi PostgreSQL):

select * 
from my_table 
where id >= trunc(
  random() * (select max(id) from my_table) + 1
) 
order by id 
limit 1;

Sto lavorando a un progetto ( Rails 3.0.15, ruby ​​1.9.3-p125-perf ) in cui il db è in localhost e la tabella degli utenti ha un po 'più di 100K record .

utilizzando

ordina per RAND ()

è abbastanza lento

User.order ( "RAND (id)"). Prima

diventa

SELEZIONA users. * usersDALL'ORDINE PER RAND (id) LIMIT 1

e impiega da 8 a 12 secondi per rispondere !!

Registro delle rotaie:

Carico utente (11030,8 ms) SELEZIONA users. * DA usersORDINE PER RAND () LIMIT 1

da mysql's spiega

+----+-------------+-------+------+---------------+------+---------+------+--------+---------------------------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows   | Extra                           |
+----+-------------+-------+------+---------------+------+---------+------+--------+---------------------------------+
|  1 | SIMPLE      | users | ALL  | NULL          | NULL | NULL    | NULL | 110165 | Using temporary; Using filesort |
+----+-------------+-------+------+---------------+------+---------+------+--------+---------------------------------+

Si può vedere che non viene utilizzato alcun indice ( possible_keys = NULL ), viene creata una tabella temporanea ed è necessario un passaggio aggiuntivo per recuperare il valore desiderato ( extra = Uso temporaneo; Uso di filesort ).

D'altra parte, suddividendo la query in due parti e usando Ruby, abbiamo un ragionevole miglioramento dei tempi di risposta.

users = User.scoped.select(:id);nil
User.find( users.first( Random.rand( users.length )).last )

(; zero per console)

Registro delle rotaie:

User Load (25.2ms) SELEZIONA ID DA usersUser Load (0.2ms) SELEZIONA users. * DA usersDOVE users. id= 106854 LIMITE 1

e mysql spiega spiega perché:

+----+-------------+-------+-------+---------------+--------------------------+---------+------+--------+-------------+
| id | select_type | table | type  | possible_keys | key                      | key_len | ref  | rows   | Extra       |
+----+-------------+-------+-------+---------------+--------------------------+---------+------+--------+-------------+
|  1 | SIMPLE      | users | index | NULL          | index_users_on_user_type | 2       | NULL | 110165 | Using index |
+----+-------------+-------+-------+---------------+--------------------------+---------+------+--------+-------------+

+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
| id | select_type | table | type  | possible_keys | key     | key_len | ref   | rows | Extra |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
|  1 | SIMPLE      | users | const | PRIMARY       | PRIMARY | 4       | const |    1 |       |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+

ora possiamo usare solo gli indici e la chiave primaria e fare il lavoro circa 500 volte più velocemente!

AGGIORNARE:

come sottolineato da icantbecool nei commenti, la soluzione di cui sopra presenta un difetto se nella tabella sono presenti record eliminati.

Una soluzione in questo può essere

users_count = User.count
User.scoped.limit(1).offset(rand(users_count)).first

che si traduce in due query

SELECT COUNT(*) FROM `users`
SELECT `users`.* FROM `users` LIMIT 1 OFFSET 148794

e funziona in circa 500ms.

Se si utilizza Postgres

User.limit(5).order("RANDOM()")

Se si utilizza MySQL

User.limit(5).order("RAND()")

In entrambi i casi stai selezionando 5 record in modo casuale dalla tabella Users. Ecco la query SQL effettiva in visualizzata nella console.

SELECT * FROM users ORDER BY RANDOM() LIMIT 5

Ho fatto un gioiello di rails 3 per farlo che si comporta meglio su tavoli di grandi dimensioni e consente di concatenare relazioni e ambiti:

https://github.com/spilliton/randumb

(modifica): il comportamento predefinito della mia gemma utilizza fondamentalmente lo stesso approccio di cui sopra ora, ma hai la possibilità di utilizzare il vecchio modo se vuoi :)

Molte delle risposte pubblicate in realtà non funzioneranno bene su tabelle piuttosto grandi (1+ milioni di righe). L'ordinamento casuale richiede rapidamente alcuni secondi e anche fare un conteggio sul tavolo richiede abbastanza tempo.

Una soluzione che funziona bene per me in questa situazione è usare RANDOM()con una condizione dove:

Thing.where('RANDOM() >= 0.9').take

Su una tabella con oltre un milione di righe, questa query richiede generalmente meno di 2ms.

eccoci qui

modo di rotaie

#in your initializer
module ActiveRecord
  class Base
    def self.random
      if (c = count) != 0
        find(:first, :offset =>rand(c))
      end
    end
  end
end

uso

Model.random #returns single random object

o il secondo pensiero è

module ActiveRecord
  class Base
    def self.random
      order("RAND()")
    end
  end
end

utilizzo:

Model.random #returns shuffled collection

Questo mi è stato molto utile, tuttavia avevo bisogno di un po 'più di flessibilità, quindi è quello che ho fatto:

Caso 1: Trovare una fonte record casuale : trevor turk site
Aggiungi questo al modello Thing.rb

def self.random
    ids = connection.select_all("SELECT id FROM things")
    find(ids[rand(ids.length)]["id"].to_i) unless ids.blank?
end

quindi nel controller puoi chiamare qualcosa del genere

@thing = Thing.random

Caso 2: Trovare più record casuali (senza ripetizioni) fonte: non ricordo che
avevo bisogno di trovare 10 record casuali senza ripetizioni, quindi questo è quello che ho trovato funzionato
nel tuo controller:

thing_ids = Thing.find( :all, :select => 'id' ).map( &:id )
@things = Thing.find( (1..10).map { thing_ids.delete_at( thing_ids.size * rand ) } )

Questo troverà 10 record casuali, tuttavia vale la pena ricordare che se il database è particolarmente grande (milioni di record), questo non sarebbe l'ideale e le prestazioni saranno ostacolate. Si esibirà bene fino a qualche migliaio di dischi che era sufficiente per me.

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 }

Funziona in Rails 5 ed è indipendente da DB:

Questo nel tuo controller:

@quotes = Quote.offset(rand(Quote.count - 3)).limit(3)

Puoi, ovviamente, mettere questo in una preoccupazione come mostrato qui .

app / modelli / preoccupazioni / randomable.rb

module Randomable
  extend ActiveSupport::Concern

  class_methods do
    def random(the_count = 1)
      records = offset(rand(count - the_count)).limit(the_count)
      the_count == 1 ? records.first : records
    end
  end
end

poi...

app / modelli / book.rb

class Book < ActiveRecord::Base
  include Randomable
end

Quindi puoi usare semplicemente facendo:

Books.random

o

Books.random(3)

È possibile utilizzare sample () in ActiveRecord

Per esempio

def get_random_things_for_home_page
  find(:all).sample(5)
end

Fonte: http://thinkingeek.com/2011/07/04/easily-select-random-records-rails/

Se si utilizza Oracle

User.limit(10).order("DBMS_RANDOM.VALUE")

Produzione

SELECT * FROM users ORDER BY DBMS_RANDOM.VALUE WHERE ROWNUM <= 10

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 di risposta accettato 733.0ms.

3. l' offsetapproccio 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.

AGGIORNARE:

Esegui sul tavolo con 550.000 righe

1. Model.where(id: Model.pluck(:id).sample(10)) costo 1384.0ms

2. gem: quick_random_recordscosta solo 6.4mstotalmente

Un modo molto semplice per ottenere più record casuali dalla tabella. Questo fa 2 domande a basso costo.

Model.where(id: Model.pluck(:id).sample(3))

Puoi cambiare "3" con il numero di record casuali che desideri.

Ho appena riscontrato questo problema sviluppando una piccola applicazione in cui volevo selezionare una domanda casuale dal mio database. Ero solito:

@question1 = Question.where(:lesson_id => params[:lesson_id]).shuffle[1]

E funziona bene per me. Non posso parlare di come le prestazioni per DB più grandi, poiché questa è solo una piccola applicazione.