Daher habe ich in Rails 2 mehrere Beispiele für das Auffinden eines zufälligen Datensatzes gefunden - die bevorzugte Methode scheint zu sein:

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

Als Neuling bin ich mir nicht sicher, wie dies mit der neuen Find-Syntax in Rails 3 konstruiert werden kann.

Also, was ist der "Rails 3 Way", um einen zufälligen Datensatz zu finden?

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

oder

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

Tatsächlich funktionieren in Rails 3 alle Beispiele. Die Verwendung von Order RANDOMist für große Tische jedoch recht langsam, jedoch eher im SQL-Stil

UPD. Sie können den folgenden Trick für eine indizierte Spalte verwenden (PostgreSQL-Syntax):

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

Ich arbeite an einem Projekt ( Rails 3.0.15, Ruby 1.9.3-p125-perf ), bei dem sich die Datenbank in localhost befindet und die Benutzertabelle etwas mehr als 100.000 Datensätze enthält .

Verwenden von

Bestellung per RAND ()

ist ziemlich langsam

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

wird

SELECT users. * FROM usersORDER BY RAND (id) LIMIT 1

und dauert 8 bis 12 Sekunden zu antworten !!

Schienenprotokoll:

Benutzerlast (11030,8 ms) SELECT users. * FROM usersORDER BY RAND () LIMIT 1

von mysql erklären

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

Sie können sehen, dass kein Index verwendet wird ( simply_keys = NULL ), eine temporäre Tabelle erstellt wird und ein zusätzlicher Durchgang erforderlich ist, um den gewünschten Wert abzurufen ( extra = Temporär verwenden; Dateisortierung verwenden ).

Auf der anderen Seite haben wir durch die Aufteilung der Abfrage in zwei Teile und die Verwendung von Ruby eine angemessene Verbesserung der Antwortzeit.

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

(; Null für Konsolengebrauch)

Schienenprotokoll:

Benutzerlast (25,2 ms) SELECT id FROM usersBenutzerlast (0,2 ms) SELECT users. * FROM usersWHERE users. id= 106854 GRENZWERT 1

und mysqls erklären beweist warum:

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

Wir können jetzt nur noch Indizes und den Primärschlüssel verwenden und die Arbeit ungefähr 500 Mal schneller erledigen!

AKTUALISIEREN:

Wie von icantbecool in den Kommentaren hervorgehoben, weist die obige Lösung einen Fehler auf, wenn gelöschte Datensätze in der Tabelle enthalten sind.

Eine Problemumgehung kann sein

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

was zu zwei Abfragen übersetzt

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

und läuft in ca. 500ms.

Bei Verwendung von Postgres

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

Bei Verwendung von MySQL

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

In beiden Fällen wählen Sie 5 Datensätze zufällig aus der Benutzertabelle aus. Hier wird die aktuelle SQL-Abfrage in der Konsole angezeigt.

SELECT * FROM users ORDER BY RANDOM() LIMIT 5

Ich habe dafür ein Rails 3-Juwel erstellt, das auf großen Tischen eine bessere Leistung erbringt und es Ihnen ermöglicht, Beziehungen und Bereiche zu verketten:

https://github.com/spilliton/randumb

(Bearbeiten): Das Standardverhalten meines Edelsteins verwendet im Grunde den gleichen Ansatz wie oben, aber Sie haben die Möglichkeit, den alten Weg zu verwenden, wenn Sie möchten :)

Viele der veröffentlichten Antworten funktionieren in ziemlich großen Tabellen (über 1 Million Zeilen) nicht gut. Die zufällige Bestellung dauert schnell einige Sekunden, und das Zählen auf dem Tisch dauert ebenfalls ziemlich lange.

Eine Lösung, die in dieser Situation für mich gut funktioniert, ist die Verwendung RANDOM()mit einer where-Bedingung:

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

In einer Tabelle mit über einer Million Zeilen dauert diese Abfrage im Allgemeinen weniger als 2 ms.

Auf geht's

Schienen Weg

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

Verwendung

Model.random #returns single random object

oder der zweite Gedanke ist

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

Verwendung:

Model.random #returns shuffled collection

Das war sehr nützlich für mich, aber ich brauchte etwas mehr Flexibilität, also habe ich Folgendes getan:

Fall 1: Finden einer zufälligen Datensatzquelle : Trevor Turk Site
Fügen Sie diese zum Thing.rb-Modell hinzu

def self.random
    ids = connection.select_all("SELECT id FROM things")
    find(ids[rand(ids.length)]["id"].to_i) unless ids.blank?
end

dann können Sie in Ihrem Controller so etwas aufrufen

@thing = Thing.random

Fall 2: Finden mehrerer zufälliger Datensätze (keine Wiederholungen) Quelle:
Ich kann mich nicht erinnern, dass ich 10 zufällige Datensätze ohne Wiederholungen suchen musste. Ich fand, dass dies
in Ihrem Controller funktioniert hat :

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

Dabei werden 10 zufällige Datensätze gefunden. Es ist jedoch erwähnenswert, dass eine besonders große Datenbank (Millionen von Datensätzen) nicht ideal ist und die Leistung beeinträchtigt wird. Es wird bis zu ein paar tausend Platten gut abschneiden, was für mich ausreichend war.

Die Ruby-Methode zum zufälligen Auswählen eines Elements aus einer Liste lautet sample. Um ein effizientes samplefür ActiveRecord zu erstellen und basierend auf den vorherigen Antworten, habe ich verwendet:

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

Ich lege dies ein lib/ext/sample.rbund lade es dann mit config/initializers/monkey_patches.rb:

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

Funktioniert in Rails 5 und ist DB-unabhängig:

Dies in Ihrem Controller:

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

Sie können dies natürlich in ein Problem bringen, wie hier gezeigt .

App / Modelle / Anliegen / 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

dann...

app / models / book.rb.

class Book < ActiveRecord::Base
  include Randomable
end

Dann können Sie einfach verwenden, indem Sie:

Books.random

oder

Books.random(3)

Sie können sample () in ActiveRecord verwenden

Z.B

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

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

Bei Verwendung von Oracle

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

Ausgabe

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

Empfehlen Sie dieses Juwel dringend für zufällige Datensätze, das speziell für Tabellen mit vielen Datenzeilen entwickelt wurde:

https://github.com/haopingfan/quick_random_records

Alle anderen Antworten funktionieren mit einer großen Datenbank schlecht, mit Ausnahme dieses Edelsteins:

1. quick_random_records kosten nur 4.6mstotal.

2. die akzeptierte Antwort User.order('RAND()').limit(10)Kosten 733.0ms.

3. Der offsetAnsatz kostete 245.4mstotal.

4. die User.all.sample(10)Anflugkosten 573.4ms.

Hinweis: Meine Tabelle hat nur 120.000 Benutzer. Je mehr Datensätze Sie haben, desto größer wird der Leistungsunterschied sein.

AKTUALISIEREN:

Führen Sie eine Tabelle mit 550.000 Zeilen durch

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

2. gem: quick_random_recordskostet nur 6.4mstotal

Eine sehr einfache Möglichkeit, mehrere zufällige Datensätze aus der Tabelle abzurufen. Dies macht 2 billige Anfragen.

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

Sie können die "3" in die Anzahl der gewünschten zufälligen Datensätze ändern.

Ich bin gerade auf dieses Problem gestoßen, als ich eine kleine Anwendung entwickelt habe, in der ich eine zufällige Frage aus meiner Datenbank auswählen wollte. Ich benutzte:

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

Und es funktioniert gut für mich. Ich kann nicht darüber sprechen, wie die Leistung für größere DBs ist, da dies nur eine kleine Anwendung ist.