Enregistrement aléatoire dans ActiveRecord

Dans Rails 4 et 5, à l'aide de Postgresql ou SQLite, à l'aide de RANDOM():

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

Sans doute le même travail pour MySQL avec RAND()

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

Ce est environ 2,5 fois plus rapide que l'approche de la accepté de répondre à.

Mise en garde: C'est lent pour les grands ensembles de données avec des millions d'enregistrements, de sorte que vous voudrez peut-être ajouter un limit clause.

Analyse comparative de ces deux méthodes sur MySQL 5.1.49, Ruby 1.9.2p180 sur les produits de la table avec +5 milliers d'enregistrements:

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)

Décalage dans MySQL semble être beaucoup plus lent.

MODIFIER
J'ai aussi essayé

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

Mais j'ai dû le tuer après environ 60 secondes. MySQL a été "la Copie de tmp table sur le disque". Qui ne va pas au travail.

J'ai fait un rails 3 gem pour le gérer:

https://github.com/spilliton/randumb

Vous permettent de faire des trucs comme ça:

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

- Je utiliser ce si souvent à partir de la console j'étends ActiveRecord dans un initialiseur - Rails 4 exemple:

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

Je peux alors appel Foo.random de ramener un enregistrement aléatoire.

Lecture de l'ensemble de ces ne m'a pas donné beaucoup de confiance sur lequel de ces serait le mieux dans mon cas en particulier avec des Rails 5 et MySQL/Maria 5.5. Donc, j'ai testé quelques réponses sur ~ 65000 dossiers, et de disposer des deux la vente à emporter:

1. RAND() avec un limit est un gagnant clair.
2. Ne pas utiliser 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)

Cette réponse synthétise, valide et met à jour Mohamed répondre, ainsi que Nami WANG commentaire sur le même et Florian Pilz commentaire de la accepté de répondre - veuillez envoyer un maximum de voix pour eux!

Si vous avez besoin de sélectionner certains des résultats aléatoires dans la portée:

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

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

La méthode Ruby pour les choisissant au hasard un élément d'une liste est sample. Voulant créer un efficace sample pour ActiveRecord, et sur la base des réponses précédentes, j'ai utilisé:

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

J'ai mis cela dans lib/ext/sample.rb et puis la charger avec cette config/initializers/monkey_patches.rb:

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

Ce sera l'une requête si la taille du modèle est déjà dans le cache et deux sinon.

Pour base de données MySQL essayer: Modèle.commande("RAND()").première

Après avoir vu tant de réponses, j'ai décidé de comparer tous sur mon PostgreSQL(9.6.3) de la base de données. J'utilise une petite table de 100 000 et de s'en débarrasser le Modèle.commande("RANDOM()").en premier, car il était déjà deux ordres de grandeur plus lent.

L'aide d'une table avec de 2 500 000 entrées avec 10 colonnes les mains vers le bas le gagnant a été l'arracher d'une méthode de près de 8 fois plus rapide que le runner up(offset. J'ai seulement couru ce sur un serveur local, de sorte que le nombre peut être gonflé mais sa plus grande que l'arracher méthode est ce que je vais utiliser. Il est également intéressant de noter que cela pourrait poser des problèmes, c'est vous arracher plus de 1 résultat à la fois, parce que chacune de celles-ci sera unique aka moins aléatoire.

Arracher gagne 100 fois sur mon de 25 000 000 de lignes de la table
Edit: en fait ce temps comprend le cueillir dans la boucle si je la sors elle il fonctionne à peu près aussi rapide que simple itération sur l'id. Cependant, tout cela prend une bonne quantité de mémoire vive.

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)

Voici les données de l'exécution de 2000 fois sur mon de 100 000 de lignes de table de la règle de manière aléatoire et

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)

Ce faire:

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

Pour moi, c'est bien clair

.order('RANDOM()').limit(limit) l'air soigné, mais qui est lent pour les grandes tables, car il a besoin de récupérer et trier toutes les lignes, même si limit est 1 (en interne dans la base de données, mais pas dans les Rails). Je ne suis pas sûr à propos de MySQL, mais ce qui se passe dans Postgres. Plus d'explications dans ici et ici.

Une solution pour les grandes tables est .from("products TABLESAMPLE SYSTEM(0.5)") où 0.5 signifie 0.5%. Cependant, je trouve cette solution est encore lent si vous avez WHERE conditions qui filtrent beaucoup de lignes. Je suppose que c'est parce que TABLESAMPLE SYSTEM(0.5) extraire toutes les lignes avant de WHERE conditions s'appliquent.

Une autre solution pour les grandes tables (mais pas très aléatoire) est:

products_scope.limit(sample_size).sample(limit)

où sample_size peut être 100 (mais pas trop grand sinon c'est lent et consomme beaucoup de mémoire), et limit peut être 1. Notez que même si c'est rapide, mais il n'est pas vraiment aléatoire, c'est de l'aléatoire dans sample_size dossiers seulement.

PS: résultats des tests dans les réponses ci-dessus ne sont pas fiables (au moins dans Postgres) parce que certaines requêtes DB course à la 2ème temps peut être considérablement plus rapide que la course à la 1ère fois, grâce à DB cache. Et malheureusement, il n'existe pas de moyen facile de désactiver le cache dans Postgres pour faire de ces points de référence fiables.

Avec l'aide de RANDOM(), vous pouvez également jeter dans un champ:

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

Ou, si vous n'avez pas envie que comme un champ, il suffit de jeter dans une méthode de classe. Maintenant Thing.random travaille avec Thing.random(n).