บันทึกแบบสุ่มใน ActiveRecord

ฉันต้องการรับการบันทึกแบบสุ่มจากตารางผ่าน ActiveRecord ฉันได้ตามตัวอย่างจากJamis บั๊กจาก 2006

อย่างไรก็ตามฉันได้พบวิธีอื่นผ่านการค้นหาของ Google (ไม่สามารถกำหนดแอตทริบิวต์ด้วยลิงก์เนื่องจากข้อ จำกัด ของผู้ใช้ใหม่):

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

ฉันอยากรู้ว่าคนอื่น ๆ ที่นี่ทำได้อย่างไรหรือถ้าใครรู้ว่าจะมีประสิทธิภาพมากขึ้นอย่างไร

ฉันไม่พบวิธีที่เหมาะสมในการทำสิ่งนี้โดยไม่มีข้อความค้นหาอย่างน้อยสองข้อ

ต่อไปนี้จะใช้จำนวนที่สร้างแบบสุ่ม (ขึ้นอยู่กับจำนวนระเบียนปัจจุบัน) เป็นชดเชย

offset = rand(Model.count)

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

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

พูดตามตรงฉันเพิ่งใช้ ORDER BY RAND () หรือ RANDOM () (ขึ้นอยู่กับฐานข้อมูล) ไม่ใช่ปัญหาด้านประสิทธิภาพหากคุณไม่มีปัญหาด้านประสิทธิภาพ

ราง 6

ตามที่ระบุโดย Jason ในข้อคิดเห็นใน Rails 6 ไม่อนุญาตให้มีการขัดแย้งกับแอ็ตทริบิวต์ คุณต้องตัดค่าในArel.sql()คำสั่ง

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

ราง 5, 4

ในRails 4และ5โดยใช้PostgresqlหรือSQLiteให้ใช้RANDOM():

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

สันนิษฐานเดียวกันจะทำงานให้MySQLด้วยRAND()

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

นี่เร็วกว่าวิธีที่ประมาณ 2.5 เท่าในคำตอบที่ยอมรับได้

Caveat : สิ่งนี้ช้าสำหรับชุดข้อมูลขนาดใหญ่ที่มีเรคคอร์ดนับล้านรายการดังนั้นคุณอาจต้องการเพิ่มส่วนlimitคำสั่ง

โค้ดตัวอย่างของคุณจะเริ่มทำงานอย่างไม่ถูกต้องเมื่อมีการลบบันทึก

คุณน่าจะดีกว่าโดยใช้วิธีการสุ่มภายในฐานข้อมูลของคุณ สิ่งเหล่านี้แตกต่างกันไปขึ้นอยู่กับฐานข้อมูลที่คุณใช้ แต่: order => "RAND ()" ใช้งานได้กับ mysql และ: order => "RANDOM ()" ใช้งานได้สำหรับ postgres

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

การเปรียบเทียบทั้งสองวิธีใน MySQL 5.1.49, Ruby 1.9.2p180 บนตารางผลิตภัณฑ์ที่มีการบันทึก + 5 ล้านรายการ:

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)

ออฟเซ็ตใน MySQL นั้นช้ากว่ามาก

แก้ไข ฉันยังลอง

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

แต่ฉันต้องฆ่ามันหลังจาก ~ 60 วินาที MySQL คือ "การคัดลอกไปยังตาราง tmp บนดิสก์" นั่นจะไม่ทำงาน

ไม่จำเป็นต้องยากขนาดนั้น

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

pluckส่งคืนอาร์เรย์ของ id ทั้งหมดในตาราง sampleวิธีการในอาร์เรย์ที่แสดงรหัสสุ่มจากอาร์เรย์

สิ่งนี้ควรทำงานได้ดีโดยมีความน่าจะเป็นที่เท่ากันในการเลือกและรองรับตารางที่มีแถวที่ถูกลบ คุณสามารถผสมกับข้อ จำกัด ได้

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

และเลือกผู้ใช้แบบสุ่มที่ชอบวันศุกร์มากกว่าแค่ผู้ใช้คนอื่น

มันไม่ได้แนะนำว่าให้คุณใช้วิธีการแก้ปัญหานี้ แต่ถ้าด้วยเหตุผลบางอย่างที่คุณจริงๆต้องการที่จะสุ่มเลือกบันทึกในขณะที่เพียงทำให้การสืบค้นฐานข้อมูลหนึ่งที่คุณสามารถใช้sampleวิธีการจากArray ชั้นทับทิมซึ่งจะช่วยให้คุณสามารถเลือกไอเทมสุ่ม จากอาร์เรย์

Model.all.sample

วิธีนี้ต้องใช้แบบสอบถามฐานข้อมูลเท่านั้น แต่ช้ากว่าทางเลือกModel.offset(rand(Model.count)).firstที่ต้องการแบบสอบถามฐานข้อมูลสองรายการอย่างมีนัยสำคัญ

ฉันสร้างพลอย 3 เม็ดเพื่อจัดการสิ่งนี้:

https://github.com/spilliton/randumb

อนุญาตให้คุณทำสิ่งนี้:

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

ฉันใช้สิ่งนี้บ่อยๆจากคอนโซลฉันขยาย ActiveRecord ใน initializer - ตัวอย่าง Rails 4:

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

ฉันสามารถโทรFoo.randomเพื่อนำกลับมาบันทึกแบบสุ่ม

หนึ่งแบบสอบถามใน Postgres:

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

การใช้ออฟเซตสองเคียวรี:

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

การอ่านสิ่งเหล่านี้ไม่ได้ให้ความมั่นใจกับฉันมากนักว่าสิ่งเหล่านี้จะทำงานได้ดีที่สุดในสถานการณ์เฉพาะของฉันกับ Rails 5 และ MySQL / Maria 5.5 ดังนั้นฉันจึงทดสอบคำตอบบางส่วนใน ~ 65000 บันทึกและมีสองวิธี:

1. RAND () ที่มี a limitเป็นผู้ชนะที่ชัดเจน
2. อย่าใช้+plucksample

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)

คำตอบนี้สังเคราะห์ตรวจสอบและอัปเดตคำตอบของโมฮาเหม็ดรวมถึงความคิดเห็นของนามิหวางในแบบเดียวกันและความคิดเห็นของฟลอเรียนปิลซ์ในคำตอบที่ยอมรับ - โปรดส่งคะแนนโหวตให้พวกเขา!

คุณสามารถใช้Arrayเมธอดsampleเมธอดsampleส่งคืนออบเจกต์แบบสุ่มจากอาเรย์เพื่อใช้งานคุณเพียงแค่ต้องเอ็กซีคิวต์ในActiveRecordเคียวรีแบบง่ายๆที่ส่งคืนคอลเลกชันเช่น:

User.all.sample

จะส่งคืนสิ่งนี้:

#<User id: 25, name: "John Doe", email: "admin@example.info", created_at: "2018-04-16 19:31:12", updated_at: "2018-04-16 19:31:12">

ขอแนะนำอัญมณีนี้สำหรับการบันทึกแบบสุ่มซึ่งออกแบบมาเป็นพิเศษสำหรับตารางที่มีแถวข้อมูลจำนวนมาก:

https://github.com/haopingfan/quick_random_records

คำตอบอื่น ๆ ทั้งหมดทำงานได้ไม่ดีกับฐานข้อมูลขนาดใหญ่ยกเว้น gem นี้:

1. quick_random_records เสียค่าใช้จ่าย4.6msทั้งหมดเท่านั้น

2. ค่าใช้จ่ายUser.order('RAND()').limit(10)733.0ms

3. offsetวิธีการตอบรับที่ยอมรับมีค่าใช้จ่าย245.4msทั้งหมด

4. ค่าใช้จ่ายวิธีUser.all.sample(10)573.4ms

หมายเหตุ: ตารางของฉันมีผู้ใช้ 120,000 คนเท่านั้น ยิ่งคุณมีบันทึกมากเท่าใดความแตกต่างของประสิทธิภาพก็จะยิ่งมากขึ้นเท่านั้น

หากคุณต้องการเลือกผลลัพธ์แบบสุ่มภายในขอบเขตที่ระบุ :

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

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

sampleวิธีทับทิมสำหรับการสุ่มหยิบจากรายการคือ ต้องการสร้างประสิทธิภาพsampleสำหรับ ActiveRecord และจากคำตอบก่อนหน้านี้ฉันใช้:

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

ฉันใส่สิ่งนี้ลงไปlib/ext/sample.rbแล้วโหลดด้วยconfig/initializers/monkey_patches.rb:

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

นี่จะเป็นข้อความค้นหาหนึ่งรายการหากขนาดของแบบจำลองนั้นถูกแคชไว้แล้ว

Rails 4.2 และ Oracle :

สำหรับ oracle คุณสามารถกำหนดขอบเขตในรุ่นของคุณได้เช่น:

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

หรือ

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

แล้วสำหรับตัวอย่างเรียกมันว่า:

Model.random_order.take(10)

หรือ

Model.random_order.limit(5)

แน่นอนคุณสามารถสั่งซื้อโดยไม่มีขอบเขตเช่น:

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

สำหรับฐานข้อมูล MySQL ลองใช้: Model.order ("RAND ()") ก่อน

หากคุณใช้ PostgreSQL 9.5+ คุณสามารถใช้ประโยชน์จากTABLESAMPLEการเลือกบันทึกแบบสุ่ม

วิธีการสุ่มตัวอย่างเริ่มต้นที่สอง ( SYSTEMและBERNOULLI) ต้องการให้คุณระบุจำนวนแถวที่จะส่งกลับเป็นเปอร์เซ็นต์ของจำนวนแถวทั้งหมดในตาราง

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

สิ่งนี้ต้องทราบจำนวนของระเบียนในตารางเพื่อเลือกเปอร์เซ็นต์ที่เหมาะสมซึ่งอาจไม่สามารถค้นหาได้อย่างรวดเร็ว โชคดีที่มีtsm_system_rowsโมดูลที่ให้คุณระบุจำนวนแถวที่จะส่งกลับโดยตรง

CREATE EXTENSION tsm_system_rows;

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

หากต้องการใช้สิ่งนี้ภายใน ActiveRecord ก่อนอื่นให้เปิดใช้งานส่วนขยายภายในการโยกย้าย:

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

จากนั้นปรับเปลี่ยนfromส่วนของแบบสอบถาม:

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

ฉันไม่ทราบว่าSYSTEM_ROWSวิธีการสุ่มตัวอย่างจะสุ่มทั้งหมดหรือเพียงแค่คืนแถวแรกจากหน้าสุ่ม

ส่วนใหญ่ของข้อมูลนี้ถูกนำมาจากบล็อกโพสต์ 2ndQuadrant เขียนโดย Gulcin Yildirim

หลังจากเห็นคำตอบมากมายฉันตัดสินใจที่จะเปรียบเทียบพวกเขาทั้งหมดในฐานข้อมูล PostgreSQL (9.6.3) ของฉัน ฉันใช้ตารางขนาดเล็กกว่า 100,000 ตารางและกำจัด Model.order ("RANDOM ()") ครั้งแรกเนื่องจากมันมีขนาดสองคำสั่งช้ากว่า

การใช้ตารางที่มี 2,500,000 รายการที่มี 10 คอลัมน์มือที่ชนะเลิศคือวิธีถอนออกเร็วกว่านักวิ่งเกือบ 8 เท่า (ชดเชยฉันวิ่งแค่นี้บนเซิร์ฟเวอร์ในพื้นที่เพื่อให้ตัวเลขนั้นอาจสูงเกินจริง วิธีการคือสิ่งที่ฉันจะใช้ท้ายที่สุดนอกจากนี้ยังเป็นที่น่าสังเกตว่านี่อาจทำให้เกิดปัญหาคือคุณถอนมากกว่า 1 ผลในแต่ละครั้งเนื่องจากแต่ละอันจะไม่ซ้ำกันหรือที่สุ่มน้อย

Pluck ชนะการทำงาน 100 ครั้งในตารางแถวที่ 25,000,000 ของฉัน Edit: จริง ๆ แล้วเวลานี้รวมถึงการถอนในวงถ้าฉันเอามันออกมามันจะวิ่งเร็วเท่าการทำซ้ำง่าย ๆ บน id อย่างไรก็ตาม; ใช้ 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)

นี่คือข้อมูลกำลังทำงาน 2,000 ครั้งในตารางแถวละ 100,000 แถวของฉันเพื่อแยกแยะแบบสุ่ม

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)

คำถามที่เก่ามาก แต่ด้วย:

rand_record = Model.all.shuffle

คุณได้อาร์เรย์ของเรคคอร์ดเรียงตามลำดับแบบสุ่ม ไม่จำเป็นต้องมีอัญมณีหรือสคริปต์

หากคุณต้องการบันทึกหนึ่งรายการ:

rand_record = Model.all.shuffle.first

ฉันใหม่เอี่ยมถึง RoR แต่ฉันได้รับสิ่งนี้เพื่อฉัน:

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

มันมาจาก:

วิธีการสุ่มเรียงลำดับ (ช่วงชิง) อาร์เรย์ใน Ruby?

จะทำอย่างไร:

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

สำหรับฉันชัดเจนมาก

ฉันลองตัวอย่างของ Sam บนแอพของฉันโดยใช้ราง 4.2.8 ของเบนช์มาร์ก (ฉันใส่ 1.Category.count สำหรับการสุ่มเพราะถ้าการสุ่มใช้ 0 มันจะทำให้เกิดข้อผิดพลาด (ActiveRecord :: RecordNotFound: ไม่พบ หมวดหมู่ที่มี 'id' = 0)) และของฉันคือ:

 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)ดูเรียบร้อย แต่จะช้าสำหรับตารางขนาดใหญ่เนื่องจากต้องการดึงข้อมูลและเรียงลำดับแถวทั้งหมดแม้ว่าlimitจะเป็น 1 (ภายในฐานข้อมูล แต่ไม่อยู่ใน Rails) ฉันไม่แน่ใจเกี่ยวกับ MySQL แต่สิ่งนี้เกิดขึ้นใน Postgres คำอธิบายเพิ่มเติมในที่นี่และที่นี่

ทางออกหนึ่งสำหรับตารางที่มีขนาดใหญ่เป็น.from("products TABLESAMPLE SYSTEM(0.5)")ที่หมายถึง0.5 0.5%อย่างไรก็ตามฉันพบว่าวิธีนี้ยังช้าถ้าคุณมีWHEREเงื่อนไขที่กรองแถวจำนวนมากออก ฉันเดาว่าเป็นเพราะTABLESAMPLE SYSTEM(0.5)ดึงข้อมูลทุกแถวก่อนWHEREนำไปใช้กับเงื่อนไข

โซลูชันอื่นสำหรับตารางขนาดใหญ่ (แต่ไม่สุ่มมาก) คือ:

products_scope.limit(sample_size).sample(limit)

ที่sample_sizeสามารถ100( แต่ไม่ใหญ่เกินไปมิฉะนั้นมันช้าและสิ้นเปลืองหน่วยความจำมาก) และสามารถlimit 1โปรดทราบว่าถึงแม้ว่านี่จะเร็ว แต่ก็ไม่ได้สุ่มแบบสุ่ม แต่เป็นการสุ่มภายในsample_sizeระเบียนเท่านั้น

PS: ผลลัพธ์มาตรฐานในคำตอบข้างต้นไม่น่าเชื่อถือ (อย่างน้อยใน Postgres) เนื่องจากบางคำสั่ง DB ที่รันในครั้งที่ 2 สามารถเร็วกว่าการรันในครั้งแรกอย่างมีนัยสำคัญเนื่องจากแคช DB และน่าเสียดายที่ไม่มีวิธีง่ายๆในการปิดใช้งานแคชใน Postgres เพื่อให้การวัดประสิทธิภาพเหล่านี้เชื่อถือได้

นอกเหนือจากการใช้งานRANDOM()แล้วคุณยังสามารถโยนมันลงในขอบเขต:

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

หรือถ้าคุณไม่นึกว่ามันเป็นเพียงแค่โยนมันลงในวิธีการเรียน ตอนนี้ทำงานพร้อมกับThing.randomThing.random(n)

ขึ้นอยู่กับความหมายของ "สุ่ม" และสิ่งที่คุณต้องการจะทำจริงtakeอาจเพียงพอ

โดย "ความหมาย" ของการสุ่มฉันหมายถึง:

• คุณหมายถึงให้องค์ประกอบใด ๆ ที่ฉันไม่สนใจตำแหน่งหรือไม่ ก็เพียงพอแล้ว
• ตอนนี้ถ้าคุณหมายถึง "ให้องค์ประกอบใด ๆ กับความน่าจะเป็นธรรมที่การทดลองซ้ำ ๆ จะให้องค์ประกอบที่แตกต่างจากชุด" จากนั้นให้บังคับ "โชค" ด้วยวิธีการใด ๆ ที่กล่าวถึงในคำตอบอื่น ๆ

ตัวอย่างเช่นสำหรับการทดสอบข้อมูลตัวอย่างจะได้รับการสร้างขึ้นแบบสุ่ม anyways จึงเป็นมากกว่าเพียงพอและจะซื่อสัตย์แม้takefirst

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