ActiveRecordのランダムレコード

ActiveRecordを介してテーブルからランダムなレコードを取得する必要があります。私は2006年からのJamis Buckの例に従いました。

ただし、Google検索を介して別の方法に遭遇したこともあります（新しいユーザーの制限により、リンクに属性を付けることはできません）。

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

ここにいる他の人がどのようにそれをしたのか、または誰かがどの方法がより効率的であるかを知っているのかどうか知りたいです。

少なくとも2つのクエリなしでこれを行う理想的な方法は見つかりませんでした。

以下は、ランダムに生成された数（現在のレコードカウントまで）をオフセットとして使用します。

offset = rand(Model.count)

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

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

正直なところ、私はORDER BY RAND（）またはRANDOM（）（データベースに応じて）を使用しています。パフォーマンスの問題がなければ、パフォーマンスの問題ではありません。

Rails 6

Jasonがコメントで述べたように、Rails 6では、属性以外の引数は許可されていません。値はArel.sql()ステートメントでラップする必要があります。

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

Rails 5、4

内レール4及び5用いて、PostgresqlのまたはSQLiteのを、使用しましたRANDOM()。

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

以下のために働くだろうおそらく同じMySQLのでRAND()

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

これは、受け入れられた回答のアプローチよりも約2.5倍高速です。

警告：これは、数百万のレコードを持つ大規模なデータセットの場合は遅いため、limit句を追加する必要がある場合があります。

レコードが削除されると、サンプルコードは不正確に動作し始めます（IDが小さいアイテムを不当に優先します）

データベース内でランダムな方法を使用する方がよいでしょう。これらは使用しているDBによって異なりますが、：order => "RAND（）"はmysqlで機能し、：order => "RANDOM（）"はpostgresで機能します

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

+5.10万レコードの製品テーブルでのMySQL 5.1.49、Ruby 1.9.2p180でのこれら2つのメソッドのベンチマーク：

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配列のメソッドは、配列からランダムなIDを返します。

これは、選択の確率が等しく、行が削除されたテーブルをサポートすることで、うまく機能するはずです。制約と組み合わせることもできます。

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

そして、それによって、任意のユーザーだけでなく、金曜日が好きなランダムなユーザーを選びます。

このソリューションを使用することはお勧めしませんが、何らかの理由で実際にデータベースクエリを1つだけ実行しながらランダムにレコードを選択する場合はsample、Ruby Arrayクラスのメソッドを使用して、ランダムなアイテムを選択できます。配列から。

Model.all.sample

この方法はデータベースクエリのみModel.offset(rand(Model.count)).firstを必要としますが、2つのデータベースクエリを必要とするような方法よりもかなり低速ですが、後者の方がより好ましいです。

これを処理するために、レール3の宝石を作成しました。

https://github.com/spilliton/randumb

それはあなたがこのようなことをすることを可能にします：

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

私はこれをコンソールから頻繁に使用しています。初期化子-Rails 4の例でActiveRecordを拡張します。

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

その後、呼び出しFoo.randomてランダムなレコードを取り戻すことができます。

Postgresの1つのクエリ：

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

オフセットを使用して、2つのクエリ：

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レコードまでの回答のいくつかをテストし、2つのポイントを持っています：

1. RAND（）とa 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)

この回答は、モハメドの回答と、ナミワンの同じコメントに対するコメント、およびフローリアンピルツの承認された回答に対するコメントを合成、検証、および更新します。投票を送信してください。

あなたは使用することができるArray方法をsample方法は、sampleそれあなただけのシンプルでexecをする必要が使用するためには、配列からランダムにオブジェクトを返します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)

リストからランダムにアイテムを選ぶRubyメソッドはsampleです。sampleActiveRecordの効率を作成するために、以前の回答に基づいて、私は以下を使用しました：

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 }

これは、モデルのサイズがすでにキャッシュされている場合は1つのクエリになり、それ以外の場合は2つになります。

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（）"）。first

PostgreSQL 9.5以降を使用している場合は、 TABLESAMPLE、ランダムなレコードを選択するのにます。

2つのデフォルトのサンプリング方法（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サンプリング方法が完全にランダムになるのか、それともランダムなページから最初の行を返すだけなのかはわかりません。

この情報のほとんどは、Gulcin Yildirimが作成した2ndQuadrantブログの投稿から取得されました。

非常に多くの回答を見た後、私はそれらすべてをPostgreSQL（9.6.3）データベースでベンチマークすることにしました。より小さな100,000テーブルを使用し、Model.order（ "RANDOM（）"）。firstを取り除きました。

2,500,000エントリ、10列のテーブルを使用した場合、手に負えた勝者はpluckメソッドがrunner up（offset。メソッドは、私が最終的に使用するものです。これは、問題の原因となる可能性があることにも注意する必要があります。一度に複数の結果を取得するのは、それらの1つ1つが一意であり、ランダム性が低いためです。

Pluckは、25,000,000行のテーブルで100回実行された勝ちです。編集：実際には、この時間にループ内のPluckが含まれています。これを実行すると、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)

これは、ランダムを除外するために100,000行のテーブルで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)

非常に古い質問ですが、

rand_record = Model.all.shuffle

ランダムな順序で並べ替えて、レコードの配列を取得しました。宝石やスクリプトは必要ありません。

1つのレコードが必要な場合：

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)

私にとっては非常に明確です

ベンチマークのレール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で発生します。こことここでより多くの説明。

大きなテーブルの解決策の1つは.from("products TABLESAMPLE SYSTEM(0.5)")、の0.5意味0.5%です。ただし、WHERE多くの行をフィルターで除外する条件がある場合、この解決策はまだ遅いことがわかります。条件が適用されるTABLESAMPLE SYSTEM(0.5)前にすべての行をフェッチするためだと思いWHEREます。

大きなテーブル（ランダムではない）の別の解決策は次のとおりです。

products_scope.limit(sample_size).sample(limit)

where sample_sizeは100（ただし、大きすぎない場合は遅くなり、大量のメモリを消費します）、およびにlimitすることができます1。これは高速ですが実際にはランダムではありませんが、sample_sizeレコード内でのみランダムであることに注意してください。

PS：DBキャッシュのおかげで、2回目に実行される一部のDBクエリは1回目に実行するよりも大幅に高速になる可能性があるため、上記の回答のベンチマーク結果は（少なくともPostgresでは）信頼できません。そして残念ながら、これらのベンチマークを信頼できるものにするためにPostgresのキャッシュを無効にする簡単な方法はありません。

を使用RANDOM()するだけでなく、これをスコープにスローすることもできます。

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

または、スコープとしてそれを気に入らない場合は、クラスメソッドにスローするだけです。今、Thing.random一緒に動作しますThing.random(n)。

「ランダム」の意味と実際にやりたいことに応じて、 take十分かもしれません。

ランダムの「意味」とは、次のことを意味します。

• 私が気にしない要素を私に与えるという意味ですか？それで十分です
• ここで、「実験を繰り返すことでセットから異なる要素が得られる可能性がかなり高い要素を与えてください」という意味の場合は、他の回答で述べられている方法のいずれかで「運」を強制します。

例では、テストするために、サンプルデータがランダムにとにかく作成されている可能性があり、そうtake十二分である、とさえ、正直に言うとfirst。

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