Как запросить случайную строку в SQL?

Как я могу запросить случайную строку (или настолько близкую к действительно случайной, насколько это возможно) в чистом SQL?

21.08.2008 06:28:49
Я всегда делал это в php после того, как результаты запроса из sql ... это, вероятно, намного быстрее для обработки в соответствии с предельным 1
CheeseConQueso 23.12.2009 20:11:32
Кажется, что не существует «чистого SQL» решения, которое бы работало на каждой базе данных ... есть решение для каждого из них.
Manu 5.08.2014 16:11:17
Версия для исполнения: stackoverflow.com/questions/4329396/…
Ciro Santilli 冠状病毒审查六四事件法轮功 7.09.2015 19:38:23
28 ОТВЕТОВ
РЕШЕНИЕ

Смотрите этот пост: SQL для выбора случайной строки из таблицы базы данных . В нем рассматриваются методы, позволяющие сделать это в MySQL, PostgreSQL, Microsoft SQL Server, IBM DB2 и Oracle (по этой ссылке скопировано следующее):

Выберите случайную строку с MySQL:

SELECT column FROM table
ORDER BY RAND()
LIMIT 1

Выберите случайную строку с PostgreSQL:

SELECT column FROM table
ORDER BY RANDOM()
LIMIT 1

Выберите случайную строку с Microsoft SQL Server:

SELECT TOP 1 column FROM table
ORDER BY NEWID()

Выберите случайную строку с IBM DB2

SELECT column, RAND() as IDX 
FROM table 
ORDER BY IDX FETCH FIRST 1 ROWS ONLY

Выберите случайную запись с Oracle:

SELECT column FROM
( SELECT column FROM table
ORDER BY dbms_random.value )
WHERE rownum = 1
726
21.08.2013 16:39:40
-1 для опоры order by rand()или эквивалентов во всех dbs: |. также упоминается здесь .
AD7six 26.05.2014 09:27:04
Десять лет назад один парень сказал, что использовать ORDER BY RAND()это неправильно ...
trejder 23.06.2015 06:42:58
ORDER BY NEWID (), кажется, заметно медленнее на SQL Server. Мой запрос выглядит следующим образом: выберите топ 1000 C.CustomerId, CL.LoginName из внутреннего присоединения клиента C LinkedAccount LA на C.CustomerId = LA.CustomerId внутреннего объединения CustomerLogin CL в C.CustomerId = CL.CustomerId с помощью C.CustomerId, CL. Имя_пользователя, имеющее счет (*)> 1 порядка по NEWID () Удаление строки «порядок по NEWID ()» возвращает результаты намного быстрее.
Ben Power 26.08.2015 23:02:40
Для SQLite используйте функцию RANDOM ().
Slam 22.10.2015 22:34:44
Эти решения не масштабируются. Они O(n)с nбыть количество записей в таблице. Представьте, что у вас есть 1 миллион записей, вы действительно хотите сгенерировать 1 миллион случайных чисел или уникальных идентификаторов? Я бы лучше использовал COUNT()и включил это в новое LIMITвыражение с одним случайным числом.
Christian Hujer 2.10.2016 11:35:13

Я не знаю, насколько это эффективно, но я использовал это раньше:

SELECT TOP 1 * FROM MyTable ORDER BY newid()

Поскольку GUID довольно случайный, порядок означает, что вы получите случайную строку.

61
30.04.2015 08:52:58
Я использую сервер MS SQL, SELECT TOP 1 * FROM some_table_name ORDER BY NEWID () отлично работает для меня, спасибо за советы, ребята!
user471414 10.10.2010 08:12:47
Это точно так же, какORDER BY RAND() LIMIT 1
Ken Bloom 2.12.2010 05:04:14
Это также очень специфично для базы данных, так как использует TOP 1и newid().
Gray -- SO stop being evil 8.02.2011 15:02:39
Это плохая идея. Этот метод не будет использовать индекс, если каждый столбец не индексируется по отдельности. Таблица с 100 миллионами записей может занять очень много времени, чтобы получить одну запись.
Switch 13.12.2012 19:14:44
@ Переключатель, а какое решение вы бы предложили?
Akmal Salikhov 9.08.2018 08:02:55
 SELECT * FROM table ORDER BY RAND() LIMIT 1
0
21.08.2008 06:30:29
Десять лет назад (2005) какой-то парень сказал, что использовать ORDER BY RAND()это неправильно ...
trejder 23.06.2015 07:09:13

Вы не сказали, какой сервер вы используете. В более старых версиях SQL Server вы можете использовать это:

select top 1 * from mytable order by newid()

В SQL Server 2005 и более поздних версиях вы можете использовать TABLESAMPLEслучайную выборку, которая будет повторяться:

SELECT FirstName, LastName
FROM Contact 
TABLESAMPLE (1 ROWS) ;
13
18.04.2015 06:03:17
MSDN говорит, что newid () предпочтительнее табличного примера для действительно случайных результатов: msdn.microsoft.com/en-us/library/ms189108.aspx
Andrew Hedges 10.11.2008 23:02:50
@ Эндрю Хеджес: ЗАКАЗАТЬ NEWID () слишком дорого
Andrei Rînea 4.11.2010 14:56:57

Лучший способ - поместить случайное значение в новый столбец только для этой цели и использовать что-то вроде этого (псевдокод + SQL):

randomNo = random()
execSql("SELECT TOP 1 * FROM MyTable WHERE MyTable.Randomness > $randomNo")

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

Для решения newid () может потребоваться полное сканирование таблицы, чтобы каждой строке можно было присвоить новый guid, который будет гораздо менее производительным.

Решение rand () может вообще не работать (т. е. с MSSQL), потому что функция будет оценена только один раз, и каждой строке будет присвоен один и тот же «случайный» номер.

3
21.08.2008 06:36:10
Обтекание, когда вы получаете 0 результатов, обеспечивает доказуемо случайную выборку (а не только «достаточно хорошую»). Это решение почти масштабируется до многострочных запросов (например, «перестановка вечеринок»). Проблема в том, что результаты, как правило, выбираются в одних и тех же группах неоднократно. Чтобы обойти это, вам нужно будет перераспределить случайные числа, которые вы только что использовали. Вы можете обмануть, отслеживая randomNo и устанавливая его в max (randomness) из результатов, но затем p (строка i в запросе 1 и строка i в запросе 2) == 0, что не справедливо. Позвольте мне немного посчитать, и я вернусь к вам с действительно честной схемой.
alsuren 29.10.2009 09:25:40

Решения, такие как Jeremies:

SELECT * FROM table ORDER BY RAND() LIMIT 1

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

SELECT * FROM table WHERE num_value >= RAND() * 
    ( SELECT MAX (num_value ) FROM table ) 
ORDER BY num_value LIMIT 1

Это работает в логарифмическом времени, независимо от размера таблицы, если num_valueона проиндексирована. Одно предостережение: это предполагает, что num_valueон равномерно распределен по диапазону 0..MAX(num_value). Если ваш набор данных сильно отклоняется от этого предположения, вы получите искаженные результаты (некоторые строки будут появляться чаще других).

174
31.12.2014 13:07:17
Второе предложение не случайно. Вы не можете предсказать строку, которая будет выбрана, но если бы вам пришлось делать ставку, вы бы сделали ставку на второй ряд. И вы никогда не сделаете ставку на последний ряд, он будет менее вероятным, независимо от распределения вашего num_value и размера таблицы.
Etienne Racine 14.11.2010 17:38:31
Я знаю, что обычно функции RAND () не очень высокого качества, но, кроме этого, не могли бы вы пояснить, почему выбор не будет случайным?
Grey Panther 16.11.2010 11:43:21
Первый - НЕПРАВИЛЬНО в SQL Server. Функция RAND () вызывается только один раз на запрос, а не один раз на строку. Поэтому он всегда выбирает первый ряд (попробуйте).
Jeff Walker Code Ranger 8.02.2012 21:49:32
Второй также предполагает, что все строки учтены: возможно, он выберет строку, которая была удалена.
Sam Rueby 20.02.2012 13:56:52
@ Sam.Rueby На самом деле, num_value> = RAND () ... предел 1 гарантирует, что пустые строки будут пропущены, пока не найдет существующую строку.
ghord 22.07.2012 13:51:44

Я должен согласиться с CD-MaN: использование «ORDER BY RAND ()» будет хорошо работать для небольших столов или когда вы делаете SELECT только несколько раз.

Я также использую технику «num_value> = RAND () * ...», и если я действительно хочу получить случайные результаты, у меня есть специальный «случайный» столбец в таблице, который я обновляю раз в день или около того. Этот единственный прогон UPDATE займет некоторое время (особенно потому, что у вас должен быть индекс для этого столбца), но это намного быстрее, чем создание случайных чисел для каждой строки каждый раз, когда выполняется выбор.

0
21.08.2008 07:20:31

Для SQL Server 2005 и 2008, если мы хотим случайную выборку отдельных строк (из Books Online ):

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

Будьте осторожны, потому что TableSample на самом деле не возвращает случайную выборку строк. Он направляет ваш запрос на случайную выборку страниц размером 8 КБ, составляющих вашу строку. Затем ваш запрос выполняется по данным, содержащимся на этих страницах. Из-за того, как данные могут быть сгруппированы на этих страницах (порядок вставки и т. Д.), Это может привести к тому, что данные на самом деле не являются случайной выборкой.

Смотрите: http://www.mssqltips.com/tip.asp?tip=1308.

Эта страница MSDN для TableSample содержит пример того, как сгенерировать действительно случайную выборку данных.

http://msdn.microsoft.com/en-us/library/ms189108.aspx

0
13.05.2009 02:52:50

Для SQL Server

newid () / order by будет работать, но будет очень дорого для больших наборов результатов, потому что он должен генерировать id для каждой строки, а затем сортировать их.

TABLESAMPLE () хорош с точки зрения производительности, но вы получите совокупность результатов (будут возвращены все строки на странице).

Для лучшего выполнения истинной случайной выборки лучшим способом является случайная фильтрация строк. Я нашел следующий пример кода в электронной документации по SQL Server. Ограничение наборов результатов с помощью TABLESAMPLE :

Если вам действительно нужна случайная выборка отдельных строк, измените запрос, чтобы отфильтровать строки случайным образом, вместо использования TABLESAMPLE. Например, следующий запрос использует функцию NEWID для возврата приблизительно одного процента строк таблицы Sales.SalesOrderDetail:

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

Столбец SalesOrderID включен в выражение CHECKSUM, поэтому NEWID () оценивается один раз для каждой строки, чтобы получить выборку для каждой строки. Выражение CAST (CHECKSUM (NEWID (), SalesOrderID) & 0x7fffffff AS float / CAST (0x7fffffff AS int) оценивается как случайное значение с плавающей точкой между 0 и 1).

Когда я запускаю таблицу с 1 000 000 строк, вот мои результаты:

SET STATISTICS TIME ON
SET STATISTICS IO ON

/* newid()
   rows returned: 10000
   logical reads: 3359
   CPU time: 3312 ms
   elapsed time = 3359 ms
*/
SELECT TOP 1 PERCENT Number
FROM Numbers
ORDER BY newid()

/* TABLESAMPLE
   rows returned: 9269 (varies)
   logical reads: 32
   CPU time: 0 ms
   elapsed time: 5 ms
*/
SELECT Number
FROM Numbers
TABLESAMPLE (1 PERCENT)

/* Filter
   rows returned: 9994 (varies)
   logical reads: 3359
   CPU time: 641 ms
   elapsed time: 627 ms
*/    
SELECT Number
FROM Numbers
WHERE 0.01 >= CAST(CHECKSUM(NEWID(), Number) & 0x7fffffff AS float) 
              / CAST (0x7fffffff AS int)

SET STATISTICS IO OFF
SET STATISTICS TIME OFF

Если вы можете избежать использования TABLESAMPLE, это даст вам наилучшую производительность. В противном случае используйте метод newid () / filter. newid () / order by должен быть последним средством, если у вас большой набор результатов.

10
28.05.2009 18:23:06

Большинство решений здесь направлены на то, чтобы избежать сортировки, но им все равно нужно последовательно сканировать таблицу.

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

Следующее решение работает на PostgreSQL 8.4:

explain analyze select * from cms_refs where rec_id in 
  (select (random()*(select last_value from cms_refs_rec_id_seq))::bigint 
   from generate_series(1,10))
  limit 1;

В приведенном выше решении вы угадаете 10 различных случайных значений индекса из диапазона 0 .. [последнее значение id].

Число 10 произвольно - вы можете использовать 100 или 1000, так как оно (как ни удивительно) не сильно влияет на время отклика.

Есть также одна проблема - если у вас есть редкие идентификаторы, вы можете пропустить . Решение состоит в том, чтобы иметь план резервного копирования :) В этом случае чистый старый порядок по запросу random (). Когда объединенный идентификатор выглядит так:

explain analyze select * from cms_refs where rec_id in 
    (select (random()*(select last_value from cms_refs_rec_id_seq))::bigint 
     from generate_series(1,10))
    union all (select * from cms_refs order by random() limit 1)
    limit 1;

Не союз ВСЕ оговорка. В этом случае, если первая часть возвращает какие-либо данные, вторая НИКОГДА не выполняется!

1
2.07.2009 13:12:02

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

Другой подход состоит в том, чтобы использовать ТОП дважды, с чередующимися ордерами. Я не знаю, является ли это «чистым SQL», потому что он использует переменную в TOP, но он работает в SQL Server 2008. Вот пример, который я использую для таблицы словарных слов, если я хочу случайное слово.

SELECT TOP 1
  word
FROM (
  SELECT TOP(@idx)
    word 
  FROM
    dbo.DictionaryAbridged WITH(NOLOCK)
  ORDER BY
    word DESC
) AS D
ORDER BY
  word ASC

Конечно, @idx - это случайное целое число в диапазоне от 1 до COUNT (*) на целевой таблице включительно. Если ваш столбец проиндексирован, вы тоже извлечете из него пользу. Еще одним преимуществом является то, что вы можете использовать его в функции, поскольку NEWID () не разрешен.

Наконец, вышеупомянутый запрос выполняется примерно в 1/10 времени выполнения запроса NEWID () для той же таблицы. YYMV.

1
20.07.2010 02:03:34
ORDER BY NEWID()

принимает 7.4 milliseconds

WHERE num_value >= RAND() * (SELECT MAX(num_value) FROM table)

берет 0.0065 milliseconds!

Я определенно пойду с последним методом.

31
28.07.2013 18:51:43
Второй вариант не выберет последний ряд. Я не знаю почему - просто указывает на это.
Voldemort 8.10.2014 23:31:26
@Voldemort: rand()возвращает число с плавающей точкой, nгде 0 < n < 1. Предполагая, num_valueчто это целое число, возвращаемое значение rand() * max(num_value)будет также приведено к целому числу, таким образом, обрезая что-либо после десятичной точки. Следовательно, rand() * max(num_value)будет всегда меньше max(num_value), поэтому никогда не будет выбрана последняя строка.
Ian Kemp 18.02.2015 14:57:18
Я не буду эффективен, если мои данные будут часто удаляться - если я найду пробел, мне придется повторно выполнить весь запрос.
Loic Coenen 22.05.2017 05:26:38
@IanKemp Глупый вопрос, так почему бы не использовать SELECT MAX (num_value) + 1 ?? Поскольку rand (или RANDOM в большинстве случаев) возвращает [0,1), вы получите полный диапазон значений. Кроме того, да, вы правы, нужно исправить запрос.
tekHedd 25.12.2018 00:32:26

Если возможно, используйте сохраненные операторы, чтобы избежать неэффективности обоих индексов в RND () и создания поля номера записи.

ПОДГОТОВИТЬ RandomRecord FROM "SELECT * FROM table LIMIT?, 1";
SET @ n = FLOOR (RAND () * (ВЫБЕРИТЕ СЧЕТЧИК (*) ИЗ таблицы));
EXECUTE RandomRecord USING @n;
4
9.01.2011 06:49:44
Это решение также заботится о возврате случайных строк, когда индексированное числовое значение, используемое в приведенном выше предложении where, распределено неравномерно; так что даже если это занимает почти то же самое (постоянное) время, что и при использовании где id_value> = RAND () * MAX (id_value), это лучше.
guido 8.02.2011 22:33:03
Насколько я могу сказать, это не работает в постоянное время, оно работает в линейное время. В худшем случае @n равно количеству строк в таблице, а «SELECT * FROM table LIMIT?, 1» оценивает @n - 1 строк до тех пор, пока не доберется до последней.
Andres Riofrio 21.09.2014 05:05:45

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

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

Например (для DB2):

WITH TEMP AS (
SELECT COMLUMN, RAND() AS IDX FROM TABLE)
SELECT COLUMN FROM TABLE WHERE IDX > .5
FETCH FIRST 1 ROW ONLY
0
31.01.2011 22:35:30
После рассмотрения этого решения я обнаружил фундаментальный недостаток в моей логике. Это будет последовательно возвращать одни и те же небольшие значения настройки в начале таблицы, потому что я предполагаю, что если бы было равномерное распределение между 0 и 1, есть 50% -ная вероятность того, что первая строка будет соответствовать этим критериям.
DAVID 31.01.2011 22:59:50

Вы также можете попробовать использовать new id()функцию.

Просто напишите свой запрос и используйте порядок по new id()функциям. Это довольно случайно.

1
24.02.2012 20:55:06

Как указано в комментарии @ BillKarwin к ответу @ cnu ...

При объединении с LIMIT я обнаружил, что он работает намного лучше (по крайней мере, с PostgreSQL 9.1) для JOIN со случайным порядком, а не для непосредственного упорядочения фактических строк: например,

SELECT * FROM tbl_post AS t
JOIN ...
JOIN ( SELECT id, CAST(-2147483648 * RANDOM() AS integer) AS rand
       FROM tbl_post
       WHERE create_time >= 1349928000
     ) r ON r.id = t.id
WHERE create_time >= 1349928000 AND ...
ORDER BY r.rand
LIMIT 100

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

CAST as Integer особенно полезен для PostgreSQL 9.2, который имеет специальную оптимизацию сортировки для целочисленных и плавающих типов одинарной точности.

2
26.10.2012 20:02:00

Для MySQL получить случайную запись

 SELECT name
  FROM random AS r1 JOIN
       (SELECT (RAND() *
                     (SELECT MAX(id)
                        FROM random)) AS id)
        AS r2
 WHERE r1.id >= r2.id
 ORDER BY r1.id ASC
 LIMIT 1

Более подробно http://jan.kneschke.de/projects/mysql/order-by-rand/

1
21.07.2013 00:34:34
После проверки многих ответов, я считаю, что это лучший. Кажется, это быстро и выбирает хорошее случайное число каждый раз. Это похоже на второе предложение @GreyPanther выше, но этот ответ выбирает больше случайных чисел.
Jeff Baker 28.04.2017 05:30:10

Простой и эффективный способ от http://akinas.com/pages/en/blog/mysql_random_row/

SET @i = (SELECT FLOOR(RAND() * COUNT(*)) FROM table); PREPARE get_stmt FROM 'SELECT * FROM table LIMIT ?, 1'; EXECUTE get_stmt USING @i;
0
18.12.2013 14:45:22

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

Для MS SQL:

Минимальный пример:

select top 10 percent *
from table_name
order by rand(checksum(*))

Нормализованное время выполнения: 1,00

Пример NewId ():

select top 10 percent *
from table_name
order by newid()

Нормализованное время выполнения: 1,02

NewId()незначительно медленнее, чем rand(checksum(*)), поэтому вы можете не использовать его для больших наборов записей.

Выбор с начальным семенем:

declare @seed int
set @seed = Year(getdate()) * month(getdate()) /* any other initial seed here */

select top 10 percent *
from table_name
order by rand(checksum(*) % seed) /* any other math function here */

Если вам нужно выбрать один и тот же набор с учетом начального числа, это, похоже, работает.

1
29.07.2014 17:36:33

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

Используйте это вместо:

SELECT *
FROM employee sample(1)
WHERE rownum=1
0
3.09.2014 11:00:50

В MSSQL (протестировано на 11.0.5569) используется

SELECT TOP 100 * FROM employee ORDER BY CRYPT_GEN_RANDOM(10)

значительно быстрее, чем

SELECT TOP 100 * FROM employee ORDER BY NEWID()
1
16.04.2015 13:36:28

Для Firebird:

Select FIRST 1 column from table ORDER BY RAND()
0
28.11.2016 08:23:34

Вместо того, чтобы использовать RAND (), так как это не рекомендуется , вы можете просто получить максимальный ID (= Max):

SELECT MAX(ID) FROM TABLE;

получить случайное значение между 1.Max (= My_Generated_Random)

My_Generated_Random = rand_in_your_programming_lang_function(1..Max);

и затем запустите этот SQL:

SELECT ID FROM TABLE WHERE ID >= My_Generated_Random ORDER BY ID LIMIT 1

Обратите внимание, что он проверит любые строки, идентификаторы которых равны или выше, чем выбранное значение. Также можно найти строку внизу таблицы и получить равный или меньший идентификатор, чем My_Generated_Random, а затем изменить запрос следующим образом:

SELECT ID FROM TABLE WHERE ID <= My_Generated_Random ORDER BY ID DESC LIMIT 1
3
10.03.2017 16:33:03
Что произойдет, если сгенерированный случайный идентификатор больше не существует в таблице? Удаленные или пассивные строки, которые вы не хотите показывать пользователю, могут вызвать проблемы.
Ebleme 1.03.2019 12:25:41
Ничего. Вы получите БЛИЖАЙШЕЕ, не точное, идентификационный номер. Если вы считаете, что id = 1 будет удалено, поменяйте 1 на минимум.
forsberg 6.10.2019 13:24:08

В SQL Server вы можете комбинировать TABLESAMPLE с NEWID (), чтобы получить довольно хорошую случайность и при этом иметь скорость. Это особенно полезно, если вы действительно хотите только 1 или небольшое количество строк.

SELECT TOP 1 * FROM [table] 
TABLESAMPLE (500 ROWS) 
ORDER BY NEWID()
1
18.04.2017 00:51:45

В SQL Server 2012+ вы можете использовать запрос OFFSET FETCH, чтобы сделать это для одной случайной строки

select  * from MyTable ORDER BY id OFFSET n ROW FETCH NEXT 1 ROWS ONLY

где id - это столбец идентификаторов, а n - нужная строка - рассчитывается как случайное число между 0 и count () - 1 таблицы (смещение 0 - первая строка после всех)

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

0
28.03.2018 19:41:24

Для SQL Server 2005 и выше, расширяя ответ @ GreyPanther для случаев, когда num_valueне имеет непрерывных значений. Это работает также для случаев, когда у нас нет равномерно распределенных наборов данных, и когда num_valueэто не число, а уникальный идентификатор.

WITH CTE_Table (SelRow, num_value) 
AS 
(
    SELECT ROW_NUMBER() OVER(ORDER BY ID) AS SelRow, num_value FROM table
) 

SELECT * FROM table Where num_value = ( 
    SELECT TOP 1 num_value FROM CTE_Table  WHERE SelRow >= RAND() * (SELECT MAX(SelRow) FROM CTE_Table)
)
0
28.05.2018 08:37:56

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

SELECT column FROM table
ORDER BY RAND()
LIMIT 1
-1
6.07.2018 07:59:29