Então, eu encontrei vários exemplos para encontrar um registro aleatório no Rails 2 - o método preferido parece ser:

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

Sendo um novato, não tenho certeza de como isso pode ser construído usando a nova sintaxe de localização no Rails 3.

Então, qual é o "Rails 3 Way" para encontrar um registro aleatório?

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

ou

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

Na verdade, no Rails 3 todos os exemplos funcionarão. Mas o uso da ordem RANDOMé bastante lento para grandes tabelas, mas com mais estilo sql

UPD. Você pode usar o seguinte truque em uma coluna indexada (sintaxe do PostgreSQL):

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

Estou trabalhando em um projeto ( Rails 3.0.15, ruby ​​1.9.3-p125-perf ) em que o banco de dados está no host local e a tabela de usuários possui um pouco mais de 100 mil registros .

Usando

encomendar por RAND ()

é bem lento

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

torna-se

SELECT users. * DA usersORDEM POR RAND (id) LIMITE 1

e leva de 8 a 12 segundos para responder !!

Log do Rails:

Carga do usuário (11030.8ms) SELECT users. * DA usersORDEM POR RAND () LIMITE 1

da explicação do mysql

+----+-------------+-------+------+---------------+------+---------+------+--------+---------------------------------+
| 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 |
+----+-------------+-------+------+---------------+------+---------+------+--------+---------------------------------+

Você pode ver que nenhum índice é usado ( Chaves_Possíveis = NULL ), uma tabela temporária é criada e uma passagem extra é necessária para buscar o valor desejado ( extra = Usando temporário; Usando filesort ).

Por outro lado, dividindo a consulta em duas partes e usando Ruby, temos uma melhoria razoável no tempo de resposta.

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

(; nada para uso do console)

Log do Rails:

ID de SELEÇÃO de Carga do Usuário (25,2 ms) DE SELEÇÃO de usersCarga do Usuário (0,2 ms) users. * FROM usersWHERE users. id= 106854 LIMITE 1

e a explicação do mysql prova o porquê:

+----+-------------+-------+-------+---------------+--------------------------+---------+------+--------+-------------+
| 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 |       |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+

agora podemos usar apenas índices e a chave primária e executar o trabalho cerca de 500 vezes mais rápido!

ATUALIZAR:

como apontado por icantbecool nos comentários, a solução acima apresenta uma falha se houver registros excluídos na tabela.

Uma solução alternativa para isso pode ser

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

que se traduz em duas consultas

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

e roda em cerca de 500ms.

Se estiver usando o Postgres

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

Se estiver usando MySQL

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

Nos dois casos, você seleciona 5 registros aleatoriamente na tabela Usuários. Aqui está a consulta SQL real exibida no console.

SELECT * FROM users ORDER BY RANDOM() LIMIT 5

Fiz uma pedra preciosa rails 3 para fazer isso com melhor desempenho em tabelas grandes e permitir que você encadeie relações e escopos:

https://github.com/spilliton/randumb

(editar): O comportamento padrão da minha jóia basicamente usa a mesma abordagem acima agora, mas você tem a opção de usar da maneira antiga, se quiser :)

Muitas das respostas postadas na verdade não apresentam bom desempenho em tabelas bastante grandes (mais de 1 milhão de linhas). A ordenação aleatória demora rapidamente alguns segundos e a contagem na mesa também leva bastante tempo.

Uma solução que funciona bem para mim nessa situação é usar RANDOM()com uma condição where:

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

Em uma tabela com mais de um milhão de linhas, essa consulta geralmente leva menos de 2ms.

aqui vamos nós

trilhos maneira

#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

ou o segundo pensamento é

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

uso:

Model.random #returns shuffled collection

Isso foi muito útil para mim, no entanto, eu precisava de um pouco mais de flexibilidade, então foi isso que fiz:

Case1: Localizando uma fonte de registro aleatório : trevor turk site
Adicione isso ao modelo 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

então no seu controlador você pode chamar algo assim

@thing = Thing.random

Case2: Encontrar vários registros aleatórios (sem repetições) fonte: não consigo lembrar
Eu precisava encontrar 10 registros aleatórios sem repetições, então foi o que eu achei que funcionou
No seu controlador:

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

Isso encontrará 10 registros aleatórios, no entanto, vale ressaltar que, se o banco de dados for particularmente grande (milhões de registros), isso não seria o ideal e o desempenho será prejudicado. É vai executar bem até alguns milhares de registros, o que foi suficiente para mim.

O método Ruby para escolher aleatoriamente um item de uma lista é sample. Querendo criar um eficiente samplepara o ActiveRecord, e com base nas respostas anteriores, usei:

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

Eu coloquei isso lib/ext/sample.rbe carreguei com isso em config/initializers/monkey_patches.rb:

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

Funciona no Rails 5 e é independente do DB:

Isso no seu controlador:

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

Obviamente, você pode colocar isso em uma preocupação, como mostrado aqui .

app / modelos / preocupações / 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

então...

app / models / book.rb

class Book < ActiveRecord::Base
  include Randomable
end

Então você pode usar simplesmente fazendo:

Books.random

ou

Books.random(3)

Você pode usar sample () no ActiveRecord

Por exemplo

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 estiver usando o Oracle

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

Resultado

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

Recomenda vivamente esta gema para registros aleatórios, projetados especialmente para tabelas com muitas linhas de dados:

https://github.com/haopingfan/quick_random_records

Todas as outras respostas apresentam um desempenho ruim com um banco de dados grande, exceto esta gema:

1. quick_random_records custam apenas 4.6mstotalmente.

2. o User.order('RAND()').limit(10)custo de resposta aceito 733.0ms.

3. a offsetabordagem custou 245.4mstotalmente.

4. o User.all.sample(10)custo da abordagem 573.4ms.

Nota: Minha tabela possui apenas 120.000 usuários. Quanto mais registros você tiver, mais enorme será a diferença de desempenho.

ATUALIZAR:

Desempenho na tabela com 550.000 linhas

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

2. gem: quick_random_recordssó custa 6.4mstotalmente

Uma maneira muito fácil de obter vários registros aleatórios da tabela. Isso faz duas consultas baratas.

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

Você pode alterar o "3" para o número de registros aleatórios que desejar.

Acabei de encontrar este problema desenvolvendo um pequeno aplicativo em que desejava selecionar uma pergunta aleatória do meu banco de dados. Eu usei:

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

E está funcionando bem para mim. Não posso falar sobre como o desempenho de bancos de dados maiores, pois esse é apenas um aplicativo pequeno.