Может ты мог бы сделать

SELECT * FROM table LIMIT 10000 OFFSET FLOOR(RAND() * 190000)

There's a very interesting discussion of this type of issue here: http://www.titov.net/2005/09/21/do-not-use-order-by-rand-or-how-to-get-random-rows-from-table/

Я думаю, без каких-либо предположений о таблице, ваше решение O (n lg n) является лучшим. Хотя на самом деле с хорошим оптимизатором или немного другой техникой запрос, который вы перечисляете, может быть немного лучше, O (m * n), где m - количество желаемых случайных строк, поскольку не обязательно нужно сортировать весь большой массив , он мог искать самые маленькие m раз. Но для тех чисел, которые вы опубликовали, m в любом случае больше, чем lg n.

Мы можем попробовать три предположения:

1. в таблице есть уникальный индексированный первичный ключ

2. количество случайных строк, которые вы хотите выбрать (m), намного меньше, чем количество строк в таблице (n)

3. уникальный первичный ключ - это целое число от 1 до n без пробелов

Только с предположениями 1 и 2, я думаю, это можно сделать за O (n), хотя вам нужно будет записать весь индекс в таблицу, чтобы соответствовать предположению 3, поэтому это не обязательно быстрый O (n). Если мы можем ДОПОЛНИТЕЛЬНО предположить что-то еще хорошее о таблице, мы можем выполнить задачу за O (m log m). Предположение 3 было бы хорошим дополнительным свойством для работы. С хорошим генератором случайных чисел, который гарантировал бы отсутствие дубликатов при генерации m чисел подряд, решение O (m) было бы возможным.

Учитывая три предположения, основная идея состоит в том, чтобы сгенерировать m уникальных случайных чисел от 1 до n, а затем выбрать строки с этими ключами из таблицы. У меня сейчас нет mysql или чего-то еще, поэтому в слегка псевдокоде это будет выглядеть примерно так:

create table RandomKeys (RandomKey int)
create table RandomKeysAttempt (RandomKey int)

-- generate m random keys between 1 and n
for i = 1 to m
  insert RandomKeysAttempt select rand()*n + 1

-- eliminate duplicates
insert RandomKeys select distinct RandomKey from RandomKeysAttempt

-- as long as we don't have enough, keep generating new keys,
-- with luck (and m much less than n), this won't be necessary
while count(RandomKeys) &lt m
  NextAttempt = rand()*n + 1
  if not exists (select * from RandomKeys where RandomKey = NextAttempt)
    insert RandomKeys select NextAttempt

-- get our random rows
select *
from RandomKeys r
join table t ON r.RandomKey = t.UniqueKey

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

Просто используйте

WHERE RAND() < 0.1 

получить 10% записей или

WHERE RAND() < 0.01 

получить 1% записей и т. д.

Я думаю, что самое быстрое решение - это

select * from table where rand() <= .3

Вот почему я думаю, что это должно сработать.

• Он создаст случайное число для каждой строки. Число от 0 до 1.
• Он определяет, отображать ли эту строку, если сгенерированное число находится в диапазоне от 0 до 0,3 (30%).

Это предполагает, что rand () генерирует числа с равномерным распределением. Это самый быстрый способ сделать это.

Я видел, что кто-то рекомендовал это решение, и они были сбиты без доказательств ... вот что я бы сказал на это -

• Это O (n), но сортировка не требуется, поэтому она быстрее, чем O (n lg n)

• mysql очень способен генерировать случайные числа для каждой строки. Попробуй это -

  выберите rand () из INFORMATION_SCHEMA.TABLES limit 10;

Поскольку рассматриваемая база данных - это mySQL, это правильное решение.

Начнем с наблюдения, что мы можем получить идентификаторы таблицы (например, count 5) на основе набора:

select *
from table_name
where _id in (4, 1, 2, 5, 3)

мы можем прийти к выводу, что если бы мы могли сгенерировать строку "(4, 1, 2, 5, 3)", то у нас был бы более эффективный способ, чем RAND().

Например, в Java:

ArrayList<Integer> indices = new ArrayList<Integer>(rowsCount);
for (int i = 0; i < rowsCount; i++) {
    indices.add(i);
}
Collections.shuffle(indices);
String inClause = indices.toString().replace('[', '(').replace(']', ')');

Если в идентификаторах есть пробелы, то исходный массив массивов indices является результатом запроса sql по идентификаторам.

Очевидно, в некоторых версиях SQL есть команда TABLESAMPLE, но она не во всех реализациях SQL (особенно в Redshift).

http://technet.microsoft.com/en-us/library/ms189108(v=sql.105).aspx

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

Если вы хотите, чтобы ваш образец был независимым, вам потребуется образец с заменой. См. В Вопрос 25451034 один из примеров того, как это сделать с помощью JOIN аналогично решению user12861. Решение написано для T-SQL, но концепция работает в любой базе данных SQL.

Быстрее, чем ORDER BY RAND ()

Я проверил, что этот метод намного быстрее, чем ORDER BY RAND(), поэтому он работает за время На), и делает это впечатляюще быстро.

От http://technet.microsoft.com/en-us/library/ms189108%28v=sql.105%29.aspx:

Версия без MSSQL - это не тестировал

SELECT * FROM Sales.SalesOrderDetail
WHERE 0.01 >= RAND()

Версия MSSQL:

SELECT * FROM Sales.SalesOrderDetail
WHERE 0.01 >= CAST(CHECKSUM(NEWID(), SalesOrderID) & 0x7fffffff AS float) / CAST (0x7fffffff AS int)

Это выберет ~ 1% записей. Поэтому, если вам нужно выбрать точное количество процентов или записей, оцените свой процент с некоторым запасом прочности, а затем случайным образом извлеките лишние записи из результирующего набора, используя более дорогой метод ORDER BY RAND().

Даже быстрее

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

Например, если у вас есть индексированный столбец с равномерно распределенными целыми числами [0..max], вы можете использовать его для случайного выбора N небольших интервалов. Сделайте это динамически в своей программе, чтобы получить разные наборы для каждого запуска запроса. Этот выбор подмножества будет НА), который может на много порядков меньше, чем ваш полный набор данных.

В моем тесте я сократил время, необходимое для получения 20 (из 20 миллионов) образцов записей из 3 мин., используя ORDER BY RAND (), до 0,0 секунды!

Если вам нужны именно строки m, реально вы сгенерируете свое подмножество идентификаторов вне SQL. Большинство методов требуют в какой-то момент выбрать «n-ую» запись, а таблицы SQL на самом деле вовсе не массивы. Предположение о том, что ключи являются последовательными, чтобы просто объединить случайные целые числа между 1 и счетчиком, также трудно удовлетворить - например, MySQL не поддерживает его изначально, и условия блокировки ... сложный.

Вот решение для времени O(max(n, m lg n)) и пространства O(n), предполагающее использование простых ключей BTREE:

1. Извлечь все значения ключевого столбца таблицы данных в любом порядке в массив на вашем любимом языке сценариев в O(n).
2. Выполните Перемешивание Фишера-Йетса, остановившись после замены m, и извлеките подмассив [0:m-1] в ϴ(m).
3. "Соедините" подмассив с исходным набором данных (например, SELECT ... WHERE id IN (<subarray>)) в O(m lg n)

Любой метод, который генерирует случайное подмножество вне SQL, должен иметь как минимум эту сложность. Соединение не может быть быстрее, чем O(m lg n) с BTREE (поэтому утверждения о O(m) являются фантастикой для большинства движков), а перемешивание ограничено ниже n и m lg n и не влияет на асимптотическое поведение.

В псевдокоде Pythonic:

ids = sql.query('SELECT id FROM t')
for i in range(m):
  r = int(random() * (len(ids) - i))
  ids[i], ids[i + r] = ids[i + r], ids[i]

results = sql.query('SELECT * FROM t WHERE id IN (%s)' % ', '.join(ids[0:m-1])

Выберите 3000 случайных записей в Netezza:

WITH IDS AS (
     SELECT ID
     FROM MYTABLE;
)

SELECT ID FROM IDS ORDER BY mt_random() LIMIT 3000

Пытаться

SELECT TOP 10000 * FROM table ORDER BY NEWID()

Приведет ли это к желаемым результатам, не будучи слишком сложным?

В некоторых диалектах, таких как Microsoft SQL Server, PostgreSQL и Oracle (но не в MySQL или SQLite), вы можете сделать что-то вроде

select distinct top 10000 customer_id from nielsen.dbo.customer TABLESAMPLE (20000 rows) REPEATABLE (123);

Причина, по которой нельзя просто использовать (10000 rows) без top, заключается в том, что логика TABLESAMPLE дает вам крайне неточное количество строк (например, иногда 75% от этого, иногда в 1,25% раз больше), поэтому вы хотите увеличить выборку и выбрать точное количество, которое хотите. REPEATABLE (123) предназначен для предоставления случайного начального числа.