J'ai donc trouvé plusieurs exemples pour trouver un enregistrement aléatoire dans Rails 2 - la méthode préférée semble être:

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

Étant un débutant, je ne sais pas comment cela pourrait être construit en utilisant la nouvelle syntaxe de recherche dans Rails 3.

Alors, quel est le "Rails 3 Way" pour trouver un enregistrement aléatoire?

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

En fait, dans Rails 3, tous les exemples fonctionneront. Mais l'utilisation de l'ordre RANDOMest assez lente pour les grandes tables mais plus de style SQL

UPD. Vous pouvez utiliser l'astuce suivante sur une colonne indexée (syntaxe PostgreSQL):

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

Je travaille sur un projet ( Rails 3.0.15, ruby ​​1.9.3-p125-perf ) où se trouve la base de données localhost et la table des utilisateurs a un peu plus de 100K enregistrements .

En utilisant

ordre par RAND ()

est assez lent

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

devient

SÉLECTIONNER users. * DEusers ORDER BY RAND (id) LIMIT 1

et prend de 8 à 12 secondes pour répondre !!

Journal des rails:

Charge utilisateur (11030.8ms) SELECT users. * FROM usersORDER BY RAND () LIMIT 1

de mysql's expliquer

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

Vous pouvez voir qu'aucun index n'est utilisé ( possible_keys = NULL ), une table temporaire est créée et une passe supplémentaire est requise pour récupérer la valeur souhaitée ( extra = Utilisation temporaire; Utilisation de filesort ).

D'autre part, en divisant la requête en deux parties et en utilisant Ruby, nous avons une amélioration raisonnable du temps de réponse.

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

(; nul pour l'utilisation de la console)

Journal des rails:

Charge utilisateur (25,2 ms) SELECT id FROM usersCharge utilisateur (0,2 ms) SELECT users. * FROM usersWHERE users. id= 106854 LIMITE 1

et mysql's expliquent pourquoi:

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

nous pouvons maintenant utiliser uniquement les index et la clé primaire et faire le travail environ 500 fois plus vite!

METTRE À JOUR:

comme indiqué par icantbecool dans les commentaires, la solution ci-dessus présente un défaut s'il y a des enregistrements supprimés dans le tableau.

Une solution de contournement qui peut être

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

ce qui se traduit par deux requêtes

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

et fonctionne en environ 500 ms.

Si vous utilisez Postgres

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

Si vous utilisez MySQL

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

Dans les deux cas, vous sélectionnez 5 enregistrements au hasard dans la table Users. Voici la requête SQL réelle affichée dans la console.

SELECT * FROM users ORDER BY RANDOM() LIMIT 5

J'ai fait une gemme de rails 3 pour faire cela qui fonctionne mieux sur les grandes tables et vous permet d'enchaîner les relations et les portées:

https://github.com/spilliton/randumb

(modifier): Le comportement par défaut de ma gemme utilise essentiellement la même approche que ci-dessus maintenant, mais vous avez la possibilité d'utiliser l'ancienne méthode si vous le souhaitez :)

La plupart des réponses publiées ne fonctionnent pas bien sur des tableaux assez volumineux (1 + million de lignes). La commande aléatoire prend rapidement quelques secondes, et faire un compte sur la table prend également assez de temps.

Une solution qui fonctionne bien pour moi dans cette situation est d'utiliser RANDOM()avec une condition where:

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

Sur une table de plus d'un million de lignes, cette requête prend généralement moins de 2 ms.

Et c'est parti

voie de rails

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

usage

Model.random #returns single random object

ou la seconde pensée est

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

usage:

Model.random #returns shuffled collection

Cela m'a été très utile mais j'avais besoin d'un peu plus de flexibilité, c'est donc ce que j'ai fait:

Cas 1: Recherche d'une source d' enregistrement aléatoire : site
de trevor turk Ajoutez ceci au modèle 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

alors dans votre contrôleur, vous pouvez appeler quelque chose comme ça

@thing = Thing.random

Cas 2: Recherche de plusieurs enregistrements aléatoires (sans répétition) source:
je ne me souviens pas que j'avais besoin de trouver 10 enregistrements aléatoires sans répétition, voici donc ce que j'ai trouvé fonctionné
dans votre contrôleur:

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

Cela permettra de trouver 10 enregistrements aléatoires, mais il convient de mentionner que si la base de données est particulièrement volumineuse (des millions d'enregistrements), ce ne serait pas idéal et les performances en seraient affectées. Il fonctionnera bien jusqu'à quelques milliers de disques, ce qui me suffisait.

La méthode Ruby pour choisir au hasard un élément dans une liste est sample. Voulant créer un efficace samplepour 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

Je mets ceci lib/ext/sample.rbet puis le charge avec ceci dans config/initializers/monkey_patches.rb:

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

Fonctionne dans Rails 5 et est indépendant de DB:

Ceci dans votre contrôleur:

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

Vous pouvez, bien sûr, mettre cela dans un souci comme indiqué ici .

app / modèles / préoccupations / 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

puis...

app / models / book.rb

class Book < ActiveRecord::Base
  include Randomable
end

Ensuite, vous pouvez utiliser simplement en faisant:

Books.random

ou

Books.random(3)

Vous pouvez utiliser sample () dans ActiveRecord

Par exemple

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

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

Si vous utilisez Oracle

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

Production

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

Je recommande vivement ce joyau pour les enregistrements aléatoires, spécialement conçu pour les tables avec beaucoup de lignes de données:

https://github.com/haopingfan/quick_random_records

Toutes les autres réponses fonctionnent mal avec une grande base de données, à l'exception de ce joyau:

1. quick_random_records ne coûte que 4.6mstotalement.

2. le User.order('RAND()').limit(10)coût de la réponse acceptée 733.0ms.

3. l' offsetapproche a coûté 245.4mstotalement.

4. le User.all.sample(10)coût d'approche 573.4ms.

Remarque: ma table ne compte que 120 000 utilisateurs. Plus vous avez d'enregistrements, plus la différence de performances sera énorme.

METTRE À JOUR:

Performer sur une table de 550000 lignes

1. Model.where(id: Model.pluck(:id).sample(10)) Coût 1384.0ms

2. gem: quick_random_recordsne coûte que 6.4mstotalement

Un moyen très simple d'obtenir plusieurs enregistrements aléatoires de la table. Cela fait 2 requêtes bon marché.

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

Vous pouvez changer le "3" pour le nombre d'enregistrements aléatoires que vous voulez.

Je viens de rencontrer ce problème en développant une petite application dans laquelle je voulais sélectionner une question aléatoire dans ma base de données. J'ai utilisé:

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

Et ça marche bien pour moi. Je ne peux pas parler des performances des bases de données plus importantes, car il ne s'agit que d'une petite application.