Enregistrement aléatoire dans ActiveRecord

J'ai besoin d'obtenir un enregistrement aléatoire d'une table via ActiveRecord. J'ai suivi l'exemple de Jamis Buck de 2006 .

Cependant, j'ai également rencontré un autre moyen via une recherche Google (impossible d'attribuer un lien en raison de nouvelles restrictions utilisateur):

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

Je suis curieux de savoir comment les autres ici l'ont fait ou si quelqu'un sait de quelle manière serait plus efficace.

Je n'ai pas trouvé le moyen idéal de le faire sans au moins deux requêtes.

Ce qui suit utilise un nombre généré aléatoirement (jusqu'au nombre d'enregistrements actuel) comme décalage .

offset = rand(Model.count)

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

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

Pour être honnête, je viens d'utiliser ORDER BY RAND () ou RANDOM () (selon la base de données). Ce n'est pas un problème de performances si vous n'avez pas de problème de performances.

Rails 6

Comme indiqué par Jason dans les commentaires, dans Rails 6, les arguments sans attribut ne sont pas autorisés. Vous devez encapsuler la valeur dans une Arel.sql()instruction.

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

Rails 5, 4

Dans Rails 4 et 5 , en utilisant Postgresql ou SQLite , en utilisant RANDOM():

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

Vraisemblablement, la même chose fonctionnerait pour MySQL avecRAND()

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

C'est environ 2,5 fois plus rapide que l'approche de la réponse acceptée .

Attention : cela est lent pour les grands ensembles de données avec des millions d'enregistrements, vous pouvez donc ajouter une limitclause.

Votre exemple de code commencera à se comporter de manière inexacte une fois les enregistrements supprimés (il favorisera injustement les éléments avec des identifiants inférieurs)

Vous feriez probablement mieux d'utiliser les méthodes aléatoires de votre base de données. Celles-ci varient en fonction de la base de données que vous utilisez, mais: order => "RAND ()" fonctionne pour mysql et: order => "RANDOM ()" fonctionne pour postgres

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

Benchmarking de ces deux méthodes sur MySQL 5.1.49, Ruby 1.9.2p180 sur une table de produits avec + 5 millions 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)

Le décalage dans MySQL semble être beaucoup plus lent.

EDIT j'ai aussi essayé

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

Mais j'ai dû le tuer après ~ 60 secondes. MySQL était "Copier vers la table tmp sur le disque". Cela ne fonctionnera pas.

Cela n'a pas à être si difficile.

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

pluckrenvoie un tableau de tous les identifiants de la table. La sampleméthode sur le tableau, retourne un identifiant aléatoire du tableau.

Cela devrait bien fonctionner, avec une probabilité égale de sélection et de prise en charge des tables avec des lignes supprimées. Vous pouvez même le mélanger avec des contraintes.

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

Et choisissez ainsi un utilisateur aléatoire qui aime les vendredis plutôt que n'importe quel utilisateur.

Il n'est pas conseillé d'utiliser cette solution, mais si pour une raison quelconque vous voulez vraiment sélectionner au hasard un enregistrement tout en ne faisant qu'une seule requête de base de données, vous pouvez utiliser la sampleméthode de la classe Ruby Array , qui vous permet de sélectionner un élément aléatoire à partir d'un tableau.

Model.all.sample

Cette méthode ne nécessite qu'une requête de base de données, mais elle est beaucoup plus lente que les alternatives comme celles Model.offset(rand(Model.count)).firstqui nécessitent deux requêtes de base de données, bien que cette dernière soit toujours préférée.

J'ai fait un joyau de rails 3 pour gérer cela:

https://github.com/spilliton/randumb

Cela vous permet de faire des choses comme ceci:

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

Je l'utilise si souvent depuis la console que j'étends ActiveRecord dans un initialiseur - exemple Rails 4:

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

Je peux alors appeler Foo.randompour ramener un enregistrement aléatoire.

Une requête dans Postgres:

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

À l'aide d'un décalage, deux requêtes:

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

La lecture de tous ces éléments ne m'a pas donné beaucoup de confiance pour savoir lequel d'entre eux fonctionnerait le mieux dans ma situation particulière avec Rails 5 et MySQL / Maria 5.5. J'ai donc testé certaines des réponses sur ~ 65000 enregistrements et j'ai deux choses à retenir:

1. RAND () avec un limitest un gagnant clair.
2. N'utilisez pas 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 la réponse de Mohamed , ainsi que le commentaire de Nami WANG sur la même chose et le commentaire de Florian Pilz sur la réponse acceptée - veuillez leur envoyer des votes!

Vous pouvez utiliser la Arrayméthode sample, la méthode sampleretourne un objet aléatoire à partir d'un tableau, pour l'utiliser, il vous suffit d'exécuter une ActiveRecordrequête simple qui retourne une collection, par exemple:

User.all.sample

retournera quelque chose comme ceci:

#<User id: 25, name: "John Doe", email: "[email protected]", created_at: "2018-04-16 19:31:12", updated_at: "2018-04-16 19:31:12">

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

3. l' offsetapproche de réponse acceptée coûte 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.

Si vous devez sélectionner des résultats aléatoires dans la portée spécifié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 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 }

Ce sera une requête si la taille du modèle est déjà mise en cache et deux dans le cas contraire.

Rails 4.2 et Oracle :

Pour oracle, vous pouvez définir une portée sur votre modèle comme ceci:

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

ou

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

Et puis pour un échantillon, appelez-le comme ceci:

Model.random_order.take(10)

ou

Model.random_order.limit(5)

bien sûr, vous pouvez également passer une commande sans portée comme celle-ci:

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

Pour la base de données MySQL, essayez: Model.order ("RAND ()"). First

Si vous utilisez PostgreSQL 9.5+, vous pouvez profiter de TABLESAMPLE pour sélectionner un enregistrement aléatoire.

Les deux méthodes d'échantillonnage par défaut ( SYSTEMetBERNOULLI ) nécessitent que vous spécifiiez le nombre de lignes à renvoyer sous forme de pourcentage du nombre total de lignes de la table.

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

Cela nécessite de connaître la quantité d'enregistrements dans le tableau pour sélectionner le pourcentage approprié, qui peut ne pas être facile à trouver rapidement. Heureusement, il y a le tsm_system_rowsmodule qui permet de spécifier le nombre de lignes à renvoyer directement.

CREATE EXTENSION tsm_system_rows;

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

Pour l'utiliser dans ActiveRecord, activez d'abord l'extension dans une migration:

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

Puis modifiez le from clause de la requête:

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

Je ne sais pas si la SYSTEM_ROWSméthode d'échantillonnage sera entièrement aléatoire ou si elle renvoie simplement la première ligne d'une page aléatoire.

La plupart de ces informations proviennent d'un article de blog 2ndQuadrant rédigé par Gulcin Yildirim .

Après avoir vu autant de réponses, j'ai décidé de les comparer toutes sur ma base de données PostgreSQL (9.6.3). J'utilise une table plus petite de 100 000 et je me suis débarrassé du Model.order ("RANDOM ()"). D'abord car il était déjà deux ordres de grandeur plus lent.

En utilisant une table avec 2500000 entrées avec 10 colonnes, le vainqueur a été la méthode de pluck presque 8 fois plus rapide que le finaliste (offset. Je l'ai uniquement exécuté sur un serveur local afin que ce nombre puisse être gonflé, mais il est suffisamment grand pour que le pluck C'est ce que je vais finir par utiliser. Il est également intéressant de noter que cela pourrait causer des problèmes si vous tirez plus d'un résultat à la fois car chacun d'entre eux sera unique, c'est-à-dire moins aléatoire.

Pluck gagne 100 fois sur ma table de 25 000 000 lignes Edit: en fait, cette fois inclut le pluck dans la boucle si je le retire, il fonctionne à peu près aussi vite qu'une simple itération sur l'id. Toutefois; cela prend une bonne quantité 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)

Voici les données exécutées 2000 fois sur ma table de 100000 lignes pour exclure le hasard

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)

Très vieille question mais avec:

rand_record = Model.all.shuffle

Vous avez un tableau d'enregistrement, trié par ordre aléatoire. Pas besoin de gemmes ou de scripts.

Si vous voulez un enregistrement:

rand_record = Model.all.shuffle.first

Je suis tout nouveau sur RoR mais j'ai obtenu que cela fonctionne pour moi:

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

C'est venu de:

Comment trier (brouiller) au hasard un tableau dans Ruby?

Que faire:

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

Pour moi c'est bien clair

J'essaie l'exemple de Sam sur mon application en utilisant les rails 4.2.8 de Benchmark (je mets 1..Category.count pour aléatoire, car si le hasard prend un 0, il produira une erreur (ActiveRecord :: RecordNotFound: Could not find Catégorie avec 'id' = 0)) et le mien était:

 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)semble soigné mais est lent pour les grandes tables car il doit récupérer et trier toutes les lignes même si limitest 1 (en interne dans la base de données mais pas dans Rails). Je ne suis pas sûr de MySQL mais cela se produit dans Postgres. Plus d'explications ici et ici .

Une solution pour les grandes tables est .from("products TABLESAMPLE SYSTEM(0.5)")où les 0.5moyens 0.5%. Cependant, je trouve que cette solution est encore lente si vous avez des WHEREconditions qui filtrent beaucoup de lignes. Je suppose que c'est parce que TABLESAMPLE SYSTEM(0.5)récupérez toutes les lignes avant que les WHEREconditions ne s'appliquent.

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

products_scope.limit(sample_size).sample(limit)

où sample_sizepeut être 100(mais pas trop grand sinon c'est lent et consomme beaucoup de mémoire), et limitpeut être 1. Notez que bien que ce soit rapide mais pas vraiment aléatoire, il est aléatoire sample_sizeuniquement dans les enregistrements.

PS: Les résultats de référence dans les réponses ci-dessus ne sont pas fiables (du moins dans Postgres) car certaines requêtes DB exécutées à la deuxième fois peuvent être beaucoup plus rapides que celles exécutées à la première fois, grâce au cache DB. Et malheureusement, il n'y a pas de moyen simple de désactiver le cache dans Postgres pour rendre ces benchmarks fiables.

En plus de l'utilisation RANDOM(), vous pouvez également jeter ceci dans une portée:

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

Ou, si vous n'aimez pas cela comme une portée, jetez-la simplement dans une méthode de classe. Fonctionne maintenant Thing.randomavec Thing.random(n).

En fonction de la signification du mot «aléatoire» et de ce que vous voulez réellement faire, take cela peut suffire.

Par «signification» de aléatoire, je veux dire:

• Voulez-vous dire, donnez-moi un élément dont je me fiche de sa position? alors c'est assez.
• Maintenant, si vous voulez dire "donnez-moi n'importe quel élément avec une bonne probabilité que des expériences répétées me donneront des éléments différents de l'ensemble" alors, forcez la "chance" avec l'une des méthodes mentionnées dans les autres réponses.

Par exemple, pour les tests, des échantillons de données auraient pu être créés au hasard de toute façon, c'est donc takeplus que suffisant, et pour être honnête, même first.

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