Registro aleatório no ActiveRecord

Estou precisando obter um registro aleatório de uma tabela via ActiveRecord. Eu segui o exemplo de Jamis Buck de 2006 .

No entanto, também deparei com outra maneira através de uma pesquisa no Google (não é possível atribuir um link devido a novas restrições de usuário):

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

Estou curioso para saber como outras pessoas o fizeram ou se alguém sabe de que maneira seria mais eficiente.

Não encontrei a maneira ideal de fazer isso sem pelo menos duas consultas.

A seguir, utiliza-se um número gerado aleatoriamente (até a contagem atual de registros) como deslocamento .

offset = rand(Model.count)

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

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

Para ser sincero, acabei de usar ORDER BY RAND () ou RANDOM () (dependendo do banco de dados). Não é um problema de desempenho se você não tiver um problema de desempenho.

Trilhos 6

Conforme afirma Jason nos comentários, no Rails 6, argumentos não relacionados a atributos não são permitidos. Você deve agrupar o valor em uma Arel.sql()instrução

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

Trilhos 5, 4

Nos Rails 4 e 5 , usando Postgresql ou SQLite , usando RANDOM():

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

Presumivelmente, o mesmo funcionaria para o MySQL comRAND()

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

Isso é cerca de 2,5 vezes mais rápido que a abordagem na resposta aceita .

Advertência : isso é lento para grandes conjuntos de dados com milhões de registros, portanto, você pode querer adicionar uma limitcláusula.

Seu código de exemplo começará a se comportar de maneira imprecisa quando os registros forem excluídos (favorecerá injustamente itens com IDs mais baixos)

Você provavelmente está melhor usando os métodos aleatórios no seu banco de dados. Isso varia dependendo do banco de dados que você está usando, mas: order => "RAND ()" funciona no mysql e: order => "RANDOM ()" funciona no postgres

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

Comparando esses dois métodos no MySQL 5.1.49, Ruby 1.9.2p180 em uma tabela de produtos com + 5 milhões de registros:

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)

O deslocamento no MySQL parece ser muito mais lento.

EDIT Eu também tentei

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

Mas eu tive que matá-lo depois de 60 segundos. O MySQL estava "Copiando para a tabela tmp no disco". Isso não vai funcionar.

Não precisa ser tão difícil.

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

pluckretorna uma matriz de todos os IDs na tabela. O samplemétodo na matriz retorna um ID aleatório da matriz.

Isso deve ter um bom desempenho, com igual probabilidade de seleção e suporte para tabelas com linhas excluídas. Você pode até misturá-lo com restrições.

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

E, assim, escolha um usuário aleatório que goste de sextas-feiras, em vez de qualquer usuário.

Não é recomendável usar essa solução, mas se, por algum motivo, você realmente deseja selecionar aleatoriamente um registro enquanto faz apenas uma consulta ao banco de dados, você pode usar o samplemétodo da classe Ruby Array , que permite selecionar um item aleatório de uma matriz.

Model.all.sample

Esse método requer apenas consulta ao banco de dados, mas é significativamente mais lento que alternativas, como as Model.offset(rand(Model.count)).firstque requerem duas consultas ao banco de dados, embora a última ainda seja a preferida.

Eu fiz uma jóia de trilhos 3 para lidar com isso:

https://github.com/spilliton/randumb

Ele permite que você faça coisas assim:

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

Eu uso isso tantas vezes no console, estendo o ActiveRecord em um inicializador - exemplo do Rails 4:

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

Posso ligar Foo.randompara trazer de volta um registro aleatório.

Uma consulta no Postgres:

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

Usando um deslocamento, duas consultas:

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

Ler tudo isso não me deu muita confiança sobre qual deles funcionaria melhor em minha situação particular com o Rails 5 e o MySQL / Maria 5.5. Então, testei algumas das respostas em ~ 65000 registros e tenho duas alternativas:

1. RAND () com a limité um vencedor claro.
2. Não use 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)

Esta resposta sintetiza, valida e atualiza a resposta de Mohamed , bem como o comentário de Nami WANG sobre o mesmo e o comentário de Florian Pilz sobre a resposta aceita - envie votos a eles!

Você pode usar o Arraymétodo sample, o método sampleretorna um objeto aleatório de uma matriz. Para usá-lo, basta executar em uma ActiveRecordconsulta simples que retorna uma coleção, por exemplo:

User.all.sample

retornará algo como isto:

#<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">

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 733.0ms.

3. a offsetabordagem de resposta aceita custa 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.

Se você precisar selecionar alguns resultados aleatórios dentro do escopo especificado :

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

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

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 }

Essa será uma consulta se o tamanho do modelo já estiver armazenado em cache e duas caso contrário.

Rails 4.2 e Oracle :

Para a oracle, você pode definir um escopo no seu modelo da seguinte maneira:

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

ou

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

E então, para uma amostra, chame assim:

Model.random_order.take(10)

ou

Model.random_order.limit(5)

é claro que você também pode fazer um pedido sem um escopo como este:

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

Para o banco de dados MySQL, tente: Model.order ("RAND ()"). First

Se você estiver usando o PostgreSQL 9.5+, poderá tirar proveito de TABLESAMPLE para selecionar um registro aleatório.

Os dois métodos de amostragem padrão ( SYSTEMe BERNOULLI) exigem que você especifique o número de linhas a serem retornadas como uma porcentagem do número total de linhas na tabela.

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

Isso requer conhecer a quantidade de registros na tabela para selecionar a porcentagem apropriada, o que pode não ser fácil de encontrar rapidamente. Felizmente, existe o tsm_system_rowsmódulo que permite especificar o número de linhas a serem retornadas diretamente.

CREATE EXTENSION tsm_system_rows;

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

Para usar isso no ActiveRecord, primeiro habilite a extensão dentro de uma migração:

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

Em seguida, modifique a fromcláusula da consulta:

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

Não sei se o SYSTEM_ROWSmétodo de amostragem será inteiramente aleatório ou se ele retorna a primeira linha de uma página aleatória.

A maioria dessas informações foi retirada de um post do 2ndQuadrant escrito por Gulcin Yildirim .

Depois de ver tantas respostas, decidi compará-las todas no meu banco de dados PostgreSQL (9.6.3). Eu uso uma tabela menor de 100.000 e me livrei da Model.order ("RANDOM ()"). Primeiro, pois ela já era duas ordens de magnitude mais lenta.

Usando uma tabela com 2.500.000 entradas com 10 colunas, o vencedor foi o método de arranque quase 8 vezes mais rápido que o vice-campeão (deslocamento. Eu apenas o executei em um servidor local para que o número possa ser inflado, mas é maior o suficiente para que o arranque É o método que eu vou acabar usando.Também vale a pena notar que isso pode causar problemas: você obtém mais de um resultado por vez, já que cada um deles será único, menos aleatório.

O Pluck ganha rodando 100 vezes na minha tabela de 25.000.000 de linhas. Contudo; é preciso uma quantidade razoável de 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)

Aqui estão os dados em execução 2000 vezes na minha tabela de 100.000 linhas para descartar aleatoriamente

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)

Pergunta muito antiga, mas com:

rand_record = Model.all.shuffle

Você tem uma matriz de registro, classificar por ordem aleatória. Não há necessidade de gemas ou scripts.

Se você deseja um registro:

rand_record = Model.all.shuffle.first

Sou novato no RoR, mas consegui que isso funcionasse para mim:

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

Veio de:

Como ordenar (embaralhar) aleatoriamente uma matriz em Ruby?

Que tal fazer:

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

Para mim é muito claro

Eu tento este exemplo do Sam no meu aplicativo usando os trilhos 4.2.8 do Benchmark (coloquei 1..Category.count aleatoriamente, porque se o aleatório receber um 0, ele produzirá um erro (ActiveRecord :: RecordNotFound: Não foi possível encontrar Categoria com 'id' = 0)) e a mina 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)parece elegante, mas é lento para tabelas grandes porque precisa buscar e classificar todas as linhas, mesmo que limitseja 1 (internamente no banco de dados, mas não no Rails). Não tenho certeza sobre o MySQL, mas isso acontece no Postgres. Mais explicações aqui e aqui .

Uma solução para tabelas grandes é .from("products TABLESAMPLE SYSTEM(0.5)") onde 0.5significa 0.5%. No entanto, acho que essa solução ainda é lenta se você tiver WHEREcondições que filtram muitas linhas. Eu acho que é porque TABLESAMPLE SYSTEM(0.5)busca todas as linhas antes que as WHEREcondições se apliquem.

Outra solução para tabelas grandes (mas não muito aleatória) é:

products_scope.limit(sample_size).sample(limit)

onde sample_sizepode estar100 (mas não muito grande, caso contrário, é lento e consome muita memória) e limitpode estar 1. Observe que, embora isso seja rápido, mas não seja realmente aleatório, é aleatório sample_sizeapenas nos registros.

PS: Os resultados de benchmark nas respostas acima não são confiáveis ​​(pelo menos no Postgres) porque algumas consultas ao banco de dados em execução no 2º tempo podem ser significativamente mais rápidas do que na 1ª vez, graças ao cache do banco de dados. E, infelizmente, não há uma maneira fácil de desativar o cache no Postgres para tornar esses benchmarks confiáveis.

Junto com o uso RANDOM(), você também pode colocar isso em um escopo:

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

Ou, se você não gosta disso como escopo, jogue-o em um método de classe. Agora Thing.randomfunciona junto com Thing.random(n).

Dependendo do significado de "aleatório" e do que você realmente deseja fazer, takepode ser suficiente.

Com o "significado" de aleatório, quero dizer:

• Quer dizer, me dê algum elemento que eu não me importo com a posição? então é o suficiente.
• Agora, se você quer dizer "me dê qualquer elemento com uma probabilidade razoável de que experimentos repetidos me darão elementos diferentes do conjunto", force a "Sorte" com qualquer um dos métodos mencionados nas outras respostas.

Por exemplo, para testes, os dados de amostra poderiam ter sido criados aleatoriamente de qualquer maneira, portanto, takeé mais do que suficiente e, para ser sincero, até first.

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