Rekam acak dalam ActiveRecord

Saya perlu mendapatkan catatan acak dari tabel melalui ActiveRecord. Saya telah mengikuti contoh dari Jamis Buck dari 2006 .

Namun, saya juga menemukan cara lain melalui pencarian Google (tidak dapat menghubungkan dengan tautan karena batasan pengguna baru):

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

Saya ingin tahu bagaimana orang lain di sini telah melakukannya atau jika ada yang tahu cara apa yang akan lebih efisien.

Saya belum menemukan cara yang ideal untuk melakukan ini tanpa setidaknya dua pertanyaan.

Berikut ini menggunakan angka yang dibuat secara acak (hingga jumlah catatan saat ini) sebagai offset .

offset = rand(Model.count)

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

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

Sejujurnya, saya baru saja menggunakan ORDER BY RAND () atau RANDOM () (tergantung pada database). Ini bukan masalah kinerja jika Anda tidak memiliki masalah kinerja.

Rel 6

Seperti yang dinyatakan oleh Jason dalam komentar, di Rails 6, argumen non-atribut tidak diperbolehkan. Anda harus membungkus nilai dalam Arel.sql()pernyataan.

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

Rails 5, 4

Di Rails 4 dan 5 , menggunakan Postgresql atau SQLite , menggunakan RANDOM():

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

Agaknya sama dengan MySQLRAND()

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

Ini sekitar 2,5 kali lebih cepat daripada pendekatan dalam jawaban yang diterima .

Peringatan : Ini lambat untuk kumpulan data besar dengan jutaan catatan, jadi Anda mungkin ingin menambahkan limitklausa.

Kode contoh Anda akan mulai berperilaku tidak akurat setelah catatan dihapus (itu akan secara tidak adil mendukung item dengan id lebih rendah)

Anda mungkin lebih baik menggunakan metode acak di dalam basis data Anda. Ini bervariasi tergantung pada DB mana yang Anda gunakan, tetapi: order => "RAND ()" berfungsi untuk mysql dan: order => "RANDOM ()" bekerja untuk postgres

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

Benchmarking kedua metode ini pada MySQL 5.1.49, Ruby 1.9.2p180 pada tabel produk dengan + 5 juta catatan:

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)

Offset di MySQL tampaknya jauh lebih lambat.

EDIT saya juga mencoba

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

Tapi aku harus membunuhnya setelah ~ 60 detik. MySQL adalah "Menyalin ke tabel tmp di disk". Itu tidak akan berhasil.

Tidak harus sulit.

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

pluckmengembalikan array dari semua id di dalam tabel. The samplemetode pada array, mengembalikan id acak dari array.

Ini harus berkinerja baik, dengan probabilitas pemilihan yang sama dan dukungan untuk tabel dengan baris yang dihapus. Anda bahkan dapat mencampurnya dengan kendala.

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

Dan dengan demikian memilih pengguna acak yang suka Jumat bukan hanya sembarang pengguna.

Tidak disarankan agar Anda menggunakan solusi ini, tetapi jika karena alasan tertentu Anda benar - benar ingin secara acak memilih catatan sementara hanya membuat satu permintaan basis data, Anda bisa menggunakan samplemetode dari kelas Ruby Array , yang memungkinkan Anda memilih item acak dari sebuah array.

Model.all.sample

Metode ini hanya membutuhkan query database, tetapi secara signifikan lebih lambat daripada alternatif seperti Model.offset(rand(Model.count)).firstyang membutuhkan dua query database, meskipun yang terakhir masih lebih disukai.

Saya membuat permata 3 rails untuk menangani ini:

https://github.com/spilliton/randumb

Ini memungkinkan Anda melakukan hal-hal seperti ini:

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

Saya sering menggunakan ini dari konsol saya memperpanjang ActiveRecord di initializer - Rails 4 contoh:

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

Saya kemudian dapat menelepon Foo.randomuntuk membawa kembali catatan acak.

Satu permintaan di Postgres:

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

Menggunakan offset, dua kueri:

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

Membaca semua ini tidak memberi saya banyak kepercayaan tentang yang ini akan bekerja paling baik dalam situasi khusus saya dengan Rails 5 dan MySQL / Maria 5.5. Jadi saya menguji beberapa jawaban pada ~ 65000 catatan, dan meminta dua jawaban:

1. RAND () dengan a limitadalah pemenang yang jelas.
2. Jangan gunakan 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)

Jawaban ini mensintesis, memvalidasi dan memperbarui jawaban Mohamed , serta komentar Nami WANG tentang hal yang sama dan komentar Florian Pilz pada jawaban yang diterima - silakan kirim suara kepada mereka!

Anda dapat menggunakan Arraymetode ini sample, metode samplemengembalikan objek acak dari array, untuk menggunakannya Anda hanya perlu mengeksekusi dalam ActiveRecordkueri sederhana yang mengembalikan koleksi, misalnya:

User.all.sample

akan mengembalikan sesuatu seperti ini:

#<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">

Sangat merekomendasikan permata ini untuk catatan acak, yang dirancang khusus untuk tabel dengan banyak baris data:

https://github.com/haopingfan/quick_random_records

Semua jawaban lain berkinerja buruk dengan basis data besar, kecuali permata ini:

1. quick_random_records hanya membutuhkan biaya 4.6mstotal.

2. yang User.order('RAND()').limit(10)biaya 733.0ms.

3. offsetpendekatan jawaban yang diterima menghabiskan biaya 245.4mstotal.

4. yang User.all.sample(10)pendekatan biaya 573.4ms.

Catatan: Meja saya hanya memiliki 120.000 pengguna. Semakin banyak catatan yang Anda miliki, semakin besar perbedaan kinerja yang akan terjadi.

Jika Anda perlu memilih beberapa hasil acak dalam ruang lingkup yang ditentukan :

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

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

Metode Ruby untuk memilih item secara acak dari daftar adalah sample. Ingin membuat efisien sampleuntuk ActiveRecord, dan berdasarkan jawaban sebelumnya, saya menggunakan:

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

Saya memasukkan ini ke dalam lib/ext/sample.rbdan kemudian memuatnya dengan ini di config/initializers/monkey_patches.rb:

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

Ini akan menjadi satu permintaan jika ukuran model sudah di-cache dan dua sebaliknya.

Rails 4.2 dan Oracle :

Untuk oracle Anda dapat mengatur ruang lingkup pada Model Anda seperti:

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

atau

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

Dan kemudian untuk sampel menyebutnya seperti ini:

Model.random_order.take(10)

atau

Model.random_order.limit(5)

tentu saja Anda juga bisa melakukan pemesanan tanpa ruang lingkup seperti:

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

Untuk basis data MySQL, coba: Model.order ("RAND ()"). Pertama

Jika Anda menggunakan PostgreSQL 9.5+, Anda dapat memanfaatkan TABLESAMPLEuntuk memilih catatan acak.

Dua metode pengambilan sampel default ( SYSTEMdan BERNOULLI) mengharuskan Anda menentukan jumlah baris untuk dikembalikan sebagai persentase dari total jumlah baris dalam tabel.

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

Ini membutuhkan mengetahui jumlah catatan dalam tabel untuk memilih persentase yang sesuai, yang mungkin tidak mudah ditemukan dengan cepat. Untungnya, ada tsm_system_rowsmodul yang memungkinkan Anda menentukan jumlah baris yang akan dikembalikan secara langsung.

CREATE EXTENSION tsm_system_rows;

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

Untuk menggunakan ini dalam ActiveRecord, pertama-tama aktifkan ekstensi dalam migrasi:

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

Kemudian ubah fromklausa dari kueri:

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

Saya tidak tahu apakah SYSTEM_ROWSmetode pengambilan sampel akan sepenuhnya acak atau hanya mengembalikan baris pertama dari halaman acak.

Sebagian besar informasi ini diambil dari posting blog 2ndQuadrant yang ditulis oleh Gulcin Yildirim .

Setelah melihat begitu banyak jawaban, saya memutuskan untuk membandingkan semuanya pada database PostgreSQL (9.6.3) saya. Saya menggunakan meja yang lebih kecil 100.000 dan menyingkirkan Model.order ("RANDOM ()"). Pertama karena sudah dua perintah besarnya lebih lambat.

Menggunakan tabel dengan 2.500.000 entri dengan 10 kolom pemenangnya adalah metode pemetik hampir 8 kali lebih cepat dari runner up (offset. Saya hanya menjalankan ini di server lokal sehingga jumlahnya mungkin meningkat tetapi cukup besar sehingga memetiknya metode adalah apa yang saya akhirnya akan menggunakan. Ini juga perlu dicatat bahwa ini dapat menyebabkan masalah adalah Anda memetik lebih dari 1 hasil sekaligus karena masing-masing dari mereka akan menjadi unik alias kurang acak.

Pluck menang menjalankan 100 kali pada tabel baris 25.000.000 saya Sunting: sebenarnya kali ini termasuk memetik dalam loop jika saya mengeluarkannya itu berjalan sekitar secepat iterasi sederhana pada id. Namun; itu memakan cukup banyak 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)

Berikut adalah data yang berjalan 2000 kali pada tabel 100.000 baris saya untuk menyingkirkan acak

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)

Pertanyaan yang sangat lama tetapi dengan:

rand_record = Model.all.shuffle

Anda mendapat Array catatan, urutkan berdasarkan urutan acak. Tidak perlu permata atau skrip.

Jika Anda ingin satu catatan:

rand_record = Model.all.shuffle.first

Saya baru mengenal RoR, tetapi ini berhasil bagi saya:

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

Itu berasal dari:

Bagaimana cara mengurutkan (scramble) array secara acak di Ruby?

Apa yang akan dilakukan:

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

Bagi saya jauh lebih jelas

Saya mencoba ini contoh Sam di App saya menggunakan rail 4.2.8 dari Benchmark (saya meletakkan 1..Category.count untuk acak, karena jika acak mengambil 0 akan menghasilkan kesalahan (ActiveRecord :: RecordNotFound: Tidak dapat menemukan Kategori dengan 'id' = 0)) dan tambangnya adalah:

 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)terlihat rapi tetapi lambat untuk tabel besar karena perlu mengambil dan mengurutkan semua baris meskipun limit1 (secara internal dalam database tetapi tidak dalam Rails). Saya tidak yakin tentang MySQL tetapi ini terjadi di Postgres. Penjelasan lebih lanjut di sini dan di sini .

Salah satu solusi untuk tabel besar adalah di .from("products TABLESAMPLE SYSTEM(0.5)")mana 0.5berarti 0.5%. Namun, saya menemukan solusi ini masih lambat jika Anda memiliki WHEREkondisi yang menyaring banyak baris. Saya kira itu karena TABLESAMPLE SYSTEM(0.5)mengambil semua baris sebelumnyaWHERE ketentuan berlaku.

Solusi lain untuk tabel besar (tapi tidak terlalu acak) adalah:

products_scope.limit(sample_size).sample(limit)

di mana sample_sizebisa 100(tapi tidak terlalu besar kalau tidak lambat dan menghabiskan banyak memori), dan limitbisa 1. Perhatikan bahwa meskipun ini cepat tetapi tidak benar-benar acak, ini hanya acak dalam sample_sizecatatan.

PS: Hasil benchmark dalam jawaban di atas tidak dapat diandalkan (setidaknya dalam Postgres) karena beberapa permintaan DB yang berjalan pada waktu ke-2 dapat secara signifikan lebih cepat daripada berjalan pada waktu ke-1, berkat cache DB. Dan sayangnya tidak ada cara mudah untuk menonaktifkan cache di Postgres untuk membuat benchmark ini dapat diandalkan.

Seiring dengan penggunaan RANDOM(), Anda juga dapat membuang ini ke dalam ruang lingkup:

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

Atau, jika Anda tidak suka itu sebagai ruang lingkup, cukup lemparkan ke metode kelas. Sekarang Thing.randombekerja bersama Thing.random(n).

Tergantung dari arti "acak" dan apa yang sebenarnya ingin Anda lakukan, takebisa cukup.

Maksud "acak" yang saya maksud adalah:

• Apakah maksud Anda memberi saya elemen yang tidak saya pedulikan posisinya? maka itu sudah cukup.
• Sekarang, jika Anda bermaksud "beri saya elemen apa pun dengan probabilitas yang adil bahwa percobaan berulang akan memberi saya elemen berbeda dari set" maka, paksa "Keberuntungan" dengan salah satu metode yang disebutkan dalam jawaban lain.

Contoh, untuk pengujian, data sampel bisa saja dibuat secara acak, jadi takelebih dari cukup, dan jujur ​​saja first.

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