ActiveRecord中的随机记录

Question

我需要通过ActiveRecord从表中获取随机记录。我遵循Jamis Buck from 2006的示例。

不过，我也可以通过谷歌搜索遇到的另一种方式（不能用链接属性，由于新的用户限制）：

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

我很好奇别人怎样在这里已经做了它或者如果有人知道什么方式会更有效率。

Answer 1

我还没有找到一个没有至少两个查询的理想方式。

以下使用一个随机生成的数字（最多当前记录数）作为偏移量。老实说，我刚刚使用ORDER BY RAND（）或RANDOM（）（取决于数据库）。如果您没有性能问题，这不是性能问题。

Answer 2

你的示例代码将开始表现不准确，一旦记录被删除（这将有利于不公平的低IDS项目）

你可能最好使用您的数据库中随机方法。这取决于哪个DB你使用的有所不同，但：为了=> “RAND（）” 的作品MySQL和：为了=> “RANDOM（）” 的作品Postgres的

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

Answer 3

标杆MySQL的49年1月5日，红宝石1.9.2p180这两种方法在产品表+ 500万个记录：

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表”。这是行不通的。

Answer 4

我做了一个轨道3宝石处理这个问题：

https://github.com/spilliton/randumb

它可以让你做的东西是这样的：

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

Answer 5

它不告知您使用此解决方案，但如果由于某种原因你真的想要随机选择一条记录，同时只做一个数据库查询，你可以使用方法从Ruby Array class，这允许哟你从数组中选择一个随机项目。

Model.all.sample 

此方法只需要数据库查询，但它不是像Model.offset(rand(Model.count)).first需要两个数据库查询的替代显著慢，尽管后者仍然优选的。在Postgres的

Answer 6

一个查询：

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) 

Answer 7

它并不一定是困难的。

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

pluck返回表中所有id的数组。数组上的sample方法从数组中返回一个随机ID。

这应该表现良好，对于删除行的表有相同的选择和支持概率。你甚至可以将它与约束混合。

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

从而挑选喜欢周五而不是任何用户的随机用户。

Answer 8

我是全新的，以回报率，但我得到这个工作对我来说：

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

它来自：

How to randomly sort (scramble) an array in Ruby?

Answer 9

我用这个经常从我扩展控制台初始化器中的ActiveRecord - Rails 4示例：

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

然后我可以调用Foo.random带回一条随机记录。

Answer 10

在导轨4和，使用PostgreSQL的或SQLite的，使用RANDOM()：

Model.order("RANDOM()").first 

大概相同将为工作的MySQL与RAND()

Model.order("RAND()").first 

这is about 2.5 times更快比在accepted answer的方法。

警告：如果您的大型数据集含有数百万条记录，那么这很慢，因此您可能需要添加limit子句。

Answer 11

如果您需要选择规定范围内一些随机的结果：

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

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

Answer 12

Ruby的方法从列表中随机挑选的产品sample。想创造的ActiveRecord的高效sample，并基于以前的答案，我用：

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 } 

这将是一个查询如果模型的大小已经被缓存，另外两个查询。

Answer 13

对于MySQL数据库尝试：Model.order（ “RAND（）”）第一

Answer 14

的Rails 4.2和Oracle：

对于Oracle您可以在模型中设置一个范围，像这样：

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

或

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

然后FO RA样称呼它：

Model.random_order.take(10) 

或

Model.random_order.limit(5) 

当然

你也可以下订单没有范围，像这样：

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

Answer 15

如果你正在使用PostgreSQL 9.5 +，你可以利用TABLESAMPLE来选择一个随机记录。

这两种默认采样方法（SYSTEM和BERNOULLI）要求您指定要返回的行数，占表中总行数的百分比。

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

这需要知道表中的记录数量来选择适当的百分比，这可能不容易很快找到。幸运的是，有tsm_system_rows module允许您指定要直接返回的行数。

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 blog post written by Gulcin Yildirim。

Answer 16

看到这么多答案后，我决定在我的PostgreSQL（9.6.3）数据库中对它们进行基准测试。我使用了一个更小的100,000张表格，并且摆脱了Model.order（“RANDOM（）”），因为它已经慢了两个数量级。

使用一个包含10列的2,500,000个条目的表格，获胜者的胜利者是拔取方法，其速度比亚军快了近8倍（偏移量，我只在本地服务器上运行这个数字，足以说明采摘方法是我最终使用的方式，同样值得注意的是，这可能会导致问题是，您一次只采集1个以上的结果，因为其中每一个结果都是独一无二的。在我的25,000,000行表上赢得100次运行 编辑：实际上这次包括循环中的插入，如果我把它拿出来，它的运行速度和简单的迭代一样快，但是它占用相当数量的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) 

这是该数据在我的10万行的表运行2000次，以排除随机

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) 

Answer 17

什么做：

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

对我来说是非常清楚的

Answer 18

阅读所有这些并没有给我很多的信心，在Rails 5和MySQL/Maria 5.5的特殊情况下，哪一个最好。所以，我测试了一些关于〜65000所记载的答案，并有两个拿走的题：

1. RAND（）与limit是一个明显的赢家。
2. 请勿使用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) 

这个答案综合，验证和更新Mohamed's answer，以及奈王的上公认的答案相同，弗洛里安皮尔磁的评论评论 - 请发选票给他们！

Answer 19

我尝试这个山姆的例子在我的应用程序使用rails 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)