Отже, я знайшов кілька прикладів пошуку випадкової записи в Rails 2 - кращим методом, здається, є:

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

Будучи чимось новачком, я не впевнений, як це можна побудувати, використовуючи новий синтаксис пошуку в Rails 3.

Отже, що таке "Рейки 3 шляху", щоб знайти випадковий запис?

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

або

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

Власне, у Rails 3 усі приклади працюватимуть. Але використання замовлення RANDOMдосить повільне для великих столів, але більше в sql-стилі

UPD. Ви можете використовувати наступний трюк для індексованого стовпця (синтаксис PostgreSQL):

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

Я працюю над проектом ( Rails 3.0.15, ruby ​​1.9.3-p125-perf ), де db знаходиться в localhost, а таблиця користувачів має трохи більше 100K записів .

Використання

замовлення RAND ()

йде досить повільно

User.order ("RAND (id)")

стає

ВИБІР users. * ВІД usersЗАМОВЛЕННЯ ПО РАНДІ (id) ГРАНІ 1

і займає від 8 до 12 секунд щоб відповісти !!

Журнал рейок:

Навантаження користувача (11030,8 мс) ВИБІР users. * З usersЗАМОВЛЕННЯ ПО РАНДУ () ГРАНІ 1

з пояснення mysql

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

Ви можете бачити, що не використовується індекс ( можливі_keys = NULL ), створюється тимчасова таблиця і потрібен додатковий пропуск для отримання потрібного значення ( extra = Використання тимчасового; Використання файлуort ).

З іншого боку, розділивши запит на дві частини та використовуючи Ruby, ми маємо розумне покращення часу відповіді.

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

(; нуль для використання консолі)

Журнал рейок:

Навантаження користувача (25.2ms) ВИБРАТИ ідентифікатор з usersкористувальницької навантаження (0,2 мс) ВИБРАТИ users. * FROM usersWHERE users. id= 106854 ГРОМ 1

і пояснення mysql доводить, чому:

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

тепер ми можемо використовувати лише індекси та первинний ключ і робити роботу приблизно в 500 разів швидше!

ОНОВЛЕННЯ:

як вказує icantbecool у коментарях, вищезазначене рішення має недолік, якщо в таблиці є видалені записи.

Вирішення в цьому може бути

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

що перекладається на два запити

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

і працює приблизно за 500 мс.

Якщо ви використовуєте Postgres

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

Якщо використовується MySQL

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

В обох випадках ви вибираєте 5 записів випадково з таблиці Користувачі. Ось власне запит SQL, відображений у консолі.

SELECT * FROM users ORDER BY RANDOM() LIMIT 5

Для цього я зробив 3 дорогоцінні камені для рейок, які краще працюють на великих столах і дозволяють ланцюжкові відносини та сфери застосування:

https://github.com/spilliton/randumb

(редагування): поведінка мого коштовності за замовчуванням в основному використовує той самий підхід, що і вище, але у вас є можливість використовувати старий спосіб, якщо хочете :)

Багато опублікованих відповідей насправді не працюватимуть на досить великих таблицях (1+ мільйонів рядків). Випадкове замовлення швидко займає декілька секунд, а підрахунок за столом також займає досить багато часу.

Рішення, яке добре працює для мене в цій ситуації, - це використовувати RANDOM()за умови, де:

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

У таблиці, що містить понад мільйон рядків, цей запит зазвичай займає менше 2 мс.

ось і ми

рейки шлях

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

використання

Model.random #returns single random object

або друга думка є

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

використання:

Model.random #returns shuffled collection

Це було дуже корисно для мене, проте мені було потрібно трохи більшої гнучкості, тому я це робив:

Case1: Пошук одного випадкового джерела запису : сайт
trevor turk Додайте це до моделі Thing.rb

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

то у своєму контролері ви можете викликати щось подібне

@thing = Thing.random

Case2: Пошук декількох випадкових записів (без повторів) Джерело: не можу пригадати,
мені потрібно було знайти 10 випадкових записів без повторів, так що я знайшов працю
у вашому контролері:

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

Тут знайдуться 10 випадкових записів, проте варто згадати, що якщо база даних особливо велика (мільйони записів), це не буде ідеальним, а продуктивність буде утруднена. Зробить добре до кількох тисяч записів, що мені було достатньо.

Метод Ruby для випадкового вибору предмета зі списку є 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 5 і є агностичним БД:

Це у вашому контролері:

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

Звичайно, можна поставити це занепокоєння, як показано тут .

додаток / моделі / проблеми / 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

тоді...

додаток / моделі / book.rb

class Book < ActiveRecord::Base
  include Randomable
end

Тоді ви можете використовувати просто, зробивши:

Books.random

або

Books.random(3)

Ви можете використовувати sample () в ActiveRecord

Напр

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

Джерело: http://thinkingeek.com/2011/07/04/easily-select-random-records-rails/

Якщо ви використовуєте Oracle

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

Вихідні дані

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

Настійно рекомендуємо цей дорогоцінний камінь для випадкових записів, який спеціально розроблений для таблиці з великою кількістю рядків даних:

https://github.com/haopingfan/quick_random_records

Усі інші відповіді погано працюють з великою базою даних, крім цього дорогоцінного каміння:

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 користувачів. Чим більше записів у вас, тим величезнішою буде різниця у виконанні.

ОНОВЛЕННЯ:

Виконайте на столі 550 000 рядків

1. Model.where(id: Model.pluck(:id).sample(10)) вартість 1384.0ms

2. gem: quick_random_recordsтільки ціна в 6.4msцілому

Дуже простий спосіб отримати кілька випадкових записів із таблиці. Це робить 2 дешевих запиту.

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

Ви можете змінити "3" на кількість потрібних випадкових записів.

Я щойно зіткнувся з цим питанням, розробляючи невелику програму, де хотів вибрати випадкове запитання зі своєї БД. Я використав:

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

І це добре працює для мене. Я не можу говорити про те, якою є ефективність для великих БД, оскільки це лише невелика програма.