Bu yüzden, Rails 2'de rastgele bir kayıt bulmak için birkaç örnek buldum - tercih edilen yöntem şöyle görünüyor:

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

Acemi biri olarak, bunun Rails 3'teki yeni bul sözdizimi kullanılarak nasıl oluşturulacağından emin değilim.

Peki, rastgele bir kayıt bulmak için "Rails 3 Way" nedir?

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

veya

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

Aslında, Rails 3'te tüm örnekler çalışacaktır. Ancak sipariş kullanmak RANDOMbüyük tablolar için oldukça yavaş ancak daha sql tarzı

UPD. Aşağıdaki numarayı indekslenmiş bir sütunda kullanabilirsiniz (PostgreSQL sözdizimi):

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

Db'nin localhost'ta olduğu ve kullanıcılar tablosunun 100K'dan biraz fazla kayıt içerdiği bir proje ( Rails 3.0.15, ruby ​​1.9.3-p125-perf ) üzerinde çalışıyorum .

kullanma

RAND'ye göre sipariş ()

oldukça yavaş

User.order ( "RAND (id)"). İlk

olur

SEÇİN users. * usersRANDA GÖRE SIRALAMA (id) SINIRI 1

ve yanıt vermesi 8 ila 12 saniye sürer !!

Rails günlüğü:

Kullanıcı Yükü (11030.8ms) SEÇİMİ users* RANDA usersGÖRE SIRALAMA () LİMİTİ 1

mysql'in açıklamasından

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

Hiçbir indeksin kullanılmadığını ( olası_anahtarlar = NULL ), geçici bir tablo oluşturulduğunu ve istenen değeri almak için fazladan bir geçiş gerektiğini görebilirsiniz ( ekstra = Geçici kullanma; Dosya sıralaması kullanma ).

Öte yandan, sorguyu ikiye bölerek ve Ruby kullanarak yanıt süresinde makul bir iyileşme elde ettik.

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

(; konsol kullanımı için nil)

Rails günlüğü:

Kullanıcı Yükü (25,2 ms) Kullanıcı Yükünden (0,2 ms) KİMLİĞİ usersSEÇİN users. * usersNEREDEN users. id= 106854 LİMİT 1

ve mysql açıklaması nedenini kanıtlıyor:

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

artık yalnızca dizinleri ve birincil anahtarı kullanabilir ve işi yaklaşık 500 kat daha hızlı yapabiliriz!

GÜNCELLEME:

icantbecool'un yorumlarda işaret ettiği gibi, tabloda silinmiş kayıtlar varsa yukarıdaki çözümün bir kusuru vardır.

Bir geçici çözüm olabilir

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

iki sorguya çeviren

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

ve yaklaşık 500 ms'de çalışır.

Postgres kullanıyorsanız

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

MySQL kullanılıyorsa

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

Her iki durumda da Kullanıcılar tablosundan rastgele 5 kayıt seçiyorsunuz. Konsolda görüntülenen asıl SQL sorgusu burada.

SELECT * FROM users ORDER BY RANDOM() LIMIT 5

Bunu yapmak için büyük masalarda daha iyi performans gösteren ve ilişkileri ve kapsamları zincirlemenize izin veren bir 3 mücevher yaptım:

https://github.com/spilliton/randumb

(değiştir): Taşımın varsayılan davranışı temelde yukarıdaki ile aynı yaklaşımı kullanıyor, ancak isterseniz eski yöntemi kullanma seçeneğiniz var :)

Gönderilen yanıtların çoğu aslında oldukça büyük tablolarda (1 milyondan fazla satır) iyi performans göstermeyecektir. Rastgele sıralama hızlı bir şekilde birkaç saniye sürer ve masada bir sayım yapmak da oldukça uzun sürer.

Bu durumda benim için işe RANDOM()yarayan bir çözüm, nerede koşuluyla kullanmaktır:

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

Bir milyondan fazla satır içeren bir tabloda, bu sorgu genellikle 2 ms'den az sürer.

İşte başlıyoruz

ray yolu

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

kullanım

Model.random #returns single random object

veya ikinci düşünce

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

kullanımı:

Model.random #returns shuffled collection

Bu benim için çok faydalı oldu ancak biraz daha esnekliğe ihtiyacım vardı, bu yüzden yaptığım şey buydu:

Örnek 1: Rastgele bir kayıt kaynağı bulmak : trevor turk site
Bunu Thing.rb modeline ekleyin

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

denetleyicinizde böyle bir şey çağırabilirsiniz

@thing = Thing.random

Durum 2: Birden fazla rastgele kayıt bulma (tekrar yok) kaynağı:
Tekrar etmeyen 10 rastgele kayıt bulmam gerektiğini hatırlayamıyorum , bu yüzden
kontrol cihazınızda işe yaradığını buldum :

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

Bu 10 rastgele kayıt bulacaktır, ancak veritabanı özellikle büyükse (milyonlarca kayıt), bunun ideal olmayacağını ve performansın aksayacağını belirtmekte fayda var. Benim için yeterli olan birkaç bin kayda kadar iyi performans gösterecek.

Bir listeden rastgele bir öğe seçmek için Ruby yöntemi sample. sampleActiveRecord için verimli bir oluşturmak isterken ve önceki cevaplara dayanarak şunu kullandım:

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

Bunu koydum lib/ext/sample.rbve bununla birlikte yükledim config/initializers/monkey_patches.rb:

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

Rails 5'te çalışır ve DB'den bağımsızdır:

Bu, kontrol cihazınızda:

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

Elbette, bunu burada gösterildiği gibi bir endişeye koyabilirsiniz .

Uygulamanın / modeller / kaygılar / 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

sonra...

Uygulamanın / modeller / book.rb

class Book < ActiveRecord::Base
  include Randomable
end

O zaman basitçe şunları yaparak kullanabilirsiniz:

Books.random

veya

Books.random(3)

ActiveRecord'da sample () kullanabilirsiniz

Örneğin

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

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

Oracle kullanıyorsanız

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

Çıktı

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

Çok sayıda veri satırı içeren tablo için özel olarak tasarlanmış rasgele kayıtlar için bu cevheri şiddetle tavsiye edin:

https://github.com/haopingfan/quick_random_records

Bu cevher dışında, diğer tüm cevaplar büyük veri tabanında kötü performans gösterir:

1. quick_random_records yalnızca 4.6mstamamen maliyetlidir .

2. kabul edilen cevap User.order('RAND()').limit(10)maliyeti 733.0ms.

3. offsetyaklaşım maliyeti 245.4mstamamen.

4. User.all.sample(10)yaklaşım maliyeti 573.4ms.

Not: Masamda sadece 120.000 kullanıcı var. Ne kadar çok kaydınız varsa, performans farkı o kadar büyük olacaktır.

GÜNCELLEME:

550.000 sıra ile masada performans sergileyin

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

2. gem: quick_random_recordssadece maliyeti 6.4mstamamen

Tablodan çok sayıda rastgele kayıt almanın çok kolay bir yolu. Bu, 2 ucuz sorgu yapar.

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

"3" ü istediğiniz rasgele kayıt sayısına değiştirebilirsiniz.

DB'mden rastgele bir soru seçmek istediğim küçük bir uygulama geliştirirken bu sorunla karşılaştım. Kullandım:

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

Ve benim için iyi çalışıyor. Bu sadece küçük bir uygulama olduğu için daha büyük DB'ler için performansın nasıl olduğundan bahsedemem.