Вы можете проверить и сравнить план выполнения с помощью

EXPLAIN select * from table where random() < 0.01;
EXPLAIN select * from table order by random() limit 1000;

Быстрый тест на большой таблице ¹ показывает, что ORDER BY сначала сортирует всю таблицу, а затем выбирает первые 1000 элементов. Сортировка большой таблицы не только считывает эту таблицу, но также включает в себя чтение и запись временных файлов. where random() < 0.1 только сканирует полную таблицу один раз.

Для больших таблиц это может быть не то, что вы хотите, так как даже одно полное сканирование таблицы может занять дольше.

Третье предложение будет

select * from table where random() < 0.01 limit 1000;

Это останавливает сканирование таблицы, как только будет найдено 1000 строк, и, следовательно, возвращается раньше. Конечно, это немного пугает случайность, но, возможно, это достаточно хорошо в вашем случае.

Изменить: Кроме того, вы можете проверить уже заданные вопросы. Использование запроса [postgresql] random возвращает довольно много обращений.

• быстрый выбор случайных строк в Postgres
• Как получить рандомизированные строки данных из таблицы postgreSQL?
• postgres: получить случайные записи из таблицы - слишком медленно

И связанная статья depez, излагающая еще несколько подходов:

• http://www.depesz.com/index.php/2007/09/16/my-thoughts-on-getting-random-row/

¹ "большой", как в "полная таблица не помещается в память".

postgresql order by random(), выберите строки в произвольном порядке:

select your_columns from your_table ORDER BY random()

postgresql order by random() с отдельным:

select * from 
  (select distinct your_columns from your_table) table_alias
ORDER BY random()

postgresql порядок по случайному пределу одна строка:

select your_columns from your_table ORDER BY random() limit 1

Тот, у кого ORDER BY будет более медленным.

select * from table where random() < 0.01; идет запись по записи и решает случайным образом фильтровать его или нет. Это будет O(N), потому что нужно только проверять каждую запись один раз.

select * from table order by random() limit 1000; собирается сортировать всю таблицу, а затем выбрать первую 1000. Помимо любой магии вуду за кулисами, порядок O(N * log N).

Недостатком random() < 0.01 является то, что вы получите переменное количество выходных записей.

Обратите внимание, что есть лучший способ перетасовать набор данных, а не сортировать случайным: Fisher-Yates Shuffle, который работает в O(N). Однако реализация shuffle в SQL звучит как вызов.

Начиная с PostgreSQL 9.5, появился новый синтаксис, предназначенный для получения случайных элементов из таблицы:

SELECT * FROM mytable TABLESAMPLE SYSTEM (5);

В этом примере вы получите 5% элементов из mytable.

Подробнее об этом в блоге: http://www.postgresql.org/docs/current/static/sql-select.html

Вот решение, которое работает для меня. Я думаю, это очень просто понять и выполнить.

SELECT 
  field_1, 
  field_2, 
  field_2, 
  random() as ordering
FROM 
  big_table
WHERE 
  some_conditions
ORDER BY
  ordering 
LIMIT 1000;

Если вы хотите только одну строку, вы можете использовать вычисленный offset, полученный из count.

select * from table_name limit 1
offset floor(random() * (select count(*) from table_name));

select * from table order by random() limit 1000;

Если вы знаете, сколько строк вы хотите, посмотрите tsm_system_rows.

tsm_system_rows

модуль предоставляет метод выборки таблицы SYSTEM_ROWS, который может использоваться в предложении TABLESAMPLE команды SELECT.

Этот метод выборки таблиц принимает единственный целочисленный аргумент, который является максимальным числом строк для чтения. Полученный образец всегда будет содержать ровно столько строк, если только таблица не содержит достаточно строк, и в этом случае выбирается вся таблица. Подобно встроенному методу выборки системы, SYSTEM_ROWS выполняет выборочную обработку на уровне блока, так что образец не является полностью случайным, но может подвергаться эффектам кластеризации, особенно если запрашивается только небольшое количество строк.

Сначала установите расширение

CREATE EXTENSION tsm_system_rows;

Затем ваш запрос

SELECT *
FROM table
TABLESAMPLE SYSTEM_ROWS(1000);

Возможна альтернатива материализованного представления "Возможная альтернатива" изложенная Эрвином Брандстретером.

Скажите, например, что вам не нужны дубликаты в рандомизированных значениях, которые возвращаются. Таким образом, вам нужно будет установить логическое значение в первичной таблице, содержащей ваш (нерандомизированный) набор значений.

Предполагая, что это таблица ввода:

id_values  id  |   used
           ----+--------
           1   |   FALSE
           2   |   FALSE
           3   |   FALSE
           4   |   FALSE
           5   |   FALSE
           ...

Заполните таблицу ID_VALUES по мере необходимости. Затем, как описано Erwin, создайте материализованное представление, которое рандомизирует таблицу ID_VALUES:

CREATE MATERIALIZED VIEW id_values_randomized AS
  SELECT id
  FROM id_values
  ORDER BY random();

Обратите внимание, что материализованное представление не содержит используемый столбец, потому что это быстро устареет. Кроме того, представление не должно содержать другие столбцы, которые могут находиться в таблице ID_VALUES.

Чтобы получить (и "потреблять" ) случайные значения, используйте UPDATE-RETURNING на ID_VALUES, выбрав ID_VALUES from id_values_randomized с соединением и применив требуемые критерии для получения только соответствующих возможностей. Например:

UPDATE id_values
SET used = TRUE
WHERE id_values.id IN 
  (SELECT i.id
    FROM id_values_randomized r INNER JOIN id_values i ON i.id = r.id
    WHERE (NOT i.used)
    LIMIT 5)
RETURNING id;

Измените LIMIT по необходимости - если вам нужно только одно случайное значение за раз, измените LIMIT на 1.

С соответствующими индексами на ID_VALUES, я считаю, что UPDATE-RETURNING должен выполняться очень быстро с небольшой нагрузкой. Он возвращает рандомизированные значения с одной обратной связью базы данных. Критерии для "подходящих" строк могут быть такими же сложными, как требуется. Новые строки могут быть добавлены в таблицу ID_VALUES в любое время, и они станут доступными для приложения, как только обновится материализованное представление (которое, вероятно, может быть запущено в нерабочее время). Создание и обновление материализованного представления будет медленным, но его нужно выполнить только при добавлении нового идентификатора в таблицу ID_VALUES.

После того как я получил вид в режиме мысли SQL, я понял, что для моего варианта использования должен работать следующий метод.

Для моей цели я хочу выбрать определенное число (около 10-20) случайных элементов "из прошлого месяца" (подмножество, возможно, 300-400 элементов - число, которое не будет увеличиваться с увеличением активности сервера). Решение Mickaël почти соответствует законопроекту, но кажется, что вы не можете использовать TABLESAMPLE после предложения WHERE.

Здесь решение, к которому я пришел:

Во-первых, я выполнил простой запрос:

SELECT id FROM table WHERE "timestamp" > now()::Date - 30

Как только результаты были возвращены моей программе, я выбрал случайную выборку идентификаторов. Тогда я просто бежал:

SELECT * FROM table WHERE id IN (1,2,3) (где (1,2,3) - мой случайный выбор).

Я понимаю, что это не строго решение PostgreSQL, но оно красивое и простое и, если учесть ограничения масштабирования, должно работать нормально. Надеюсь, он будет подходящим для кого-то в подобном положении.

Добавьте столбец с именем r с типом serial. Индекс r.

Предположим, что у нас 200 000 строк, мы будем генерировать случайное число n, где 0 < n <= 200, 000.

Выберите строки с r > n, отсортируйте их ASC и выберите самый маленький.

код:

select * from YOUR_TABLE 
where r > (
    select (
        select reltuples::bigint AS estimate
        from   pg_class
        where  oid = 'public.YOUR_TABLE'::regclass) * random()
    )
order by r asc limit(1);

Код не требует пояснений. Подзапрос в середине используется для быстрого подсчета количества строк таблицы из https://stackoverflow.com/questions/7943233/fast-way-to-discover-the-row-count-of-a-table-in-postgresql.

На уровне приложения вам нужно снова выполнить оператор, если n > количество строк или нужно выбрать несколько строк.