Может быть, ты мог бы сделать что-нибудь вроде

SELECT * FROM table 
  WHERE id=
    (FLOOR(RAND() * 
           (SELECT COUNT(*) FROM table)
          )
    );

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

Добавьте столбец, содержащий вычисленное случайное значение, в каждую строку и используйте его в предложении упорядочивания, ограничиваясь одним результатом при выборе. Это работает быстрее, чем сканирование таблицы, вызываемое ORDER BY RANDOM().

Обновлять: Вам все равно нужно вычислить какое-то случайное значение перед выдачей оператора SELECT при извлечении, конечно, например

SELECT * FROM `foo` WHERE `foo_rand` >= {some random value} LIMIT 1

Классический "ВЫБРАТЬ идентификатор ИЗ таблицы ORDER BY RAND () LIMIT 1" на самом деле подходит.

См. Следующий отрывок из руководства MySQL:

Если вы используете LIMIT row_count с ORDER BY, MySQL завершит сортировку, как только найдет первые строки row_count отсортированного результата, вместо сортировки всего результата.

Простой, но медленный способ (подходит для небольших столов)

SELECT * from TABLE order by RAND() LIMIT 1

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

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

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

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

Не делайте этого, и вы не должны заказывать по GUID, у него та же проблема.

При заказе вы сделаете полное сканирование стола. Лучше всего, если вы выполните счетчик выбора (*), а затем получите случайную строку = rownum между 0 и последним реестром

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

sql "select id from table"
store result in list
n = random(size of list)
sql "select * from table where id = " + list[n]

Это предполагает, что id является уникальным (первичным) ключом.

Я знал, что должен быть способ сделать это с помощью одного запроса быстро. И вот оно:

Быстрый способ без использования внешнего кода, спасибо

http://jan.kneschke.de/projects/mysql/order-by-rand/

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;

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

SET @r := (SELECT ROUND(RAND() * (SELECT COUNT(*) FROM mytable)));
SET @sql := CONCAT('SELECT * FROM mytable LIMIT ', @r, ', 1');
PREPARE stmt1 FROM @sql;
EXECUTE stmt1;

MediaWiki использует интересный трюк (для функции Wikipedia Special: Random): в таблице со статьями есть дополнительный столбец со случайным числом (генерируемым при создании статьи). Чтобы получить случайную статью, сгенерируйте случайное число и получите статью со следующим большим или меньшим (не помню, какое) значение в столбце случайных чисел. С индексом это может быть очень быстро. (А MediaWiki написана на PHP и разработана для MySQL.)

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

Быстрый и грязный метод:

SET @COUNTER=SELECT COUNT(*) FROM your_table;

SELECT PrimaryKey
FROM your_table
LIMIT 1 OFFSET (RAND() * @COUNTER);

Сложность первого запроса составляет O (1) для таблиц MyISAM.

Второй запрос сопровождает полное сканирование таблицы. Сложность = O (n)

Грязный и быстрый способ:

Только для этого ведите отдельную таблицу. Вы также должны вставлять те же строки в эту таблицу при каждой вставке в исходную таблицу. Предположение: без DELETE.

CREATE TABLE Aux(
  MyPK INT AUTO_INCREMENT,
  PrimaryKey INT
);

SET @MaxPK = (SELECT MAX(MyPK) FROM Aux);
SET @RandPK = CAST(RANDOM() * @MaxPK, INT)
SET @PrimaryKey = (SELECT PrimaryKey FROM Aux WHERE MyPK = @RandPK);

Если DELETE разрешены,

SET @delta = CAST(@RandPK/10, INT);

SET @PrimaryKey = (SELECT PrimaryKey
                   FROM Aux
                   WHERE MyPK BETWEEN @RandPK - @delta AND @RandPK + @delta
                   LIMIT 1);

Общая сложность - O (1).

Я немного новичок в SQL, но как насчет создания случайного числа в PHP и использования

SELECT * FROM the_table WHERE primary_key >= $randNr

это не решает проблемы с отверстиями в столе.

Но вот поворот в предложении лассевков:

SELECT primary_key FROM the_table

Используйте mysql_num_rows () в PHP, чтобы создать случайное число на основе приведенного выше результата:

SELECT * FROM the_table WHERE primary_key = rand_number

Кстати, насколько медленен SELECT * FROM the_table:
. Создание случайного числа на основе mysql_num_rows() и последующее перемещение указателя данных в эту точку mysql_data_seek(). Насколько медленно это будет происходить на больших таблицах с миллионом строк?

Взгляните на эта ссылка Яна Кнешке или этот ТАК ответ, поскольку они оба обсуждают один и тот же вопрос. Ответ SO также включает различные варианты и дает несколько хороших предложений в зависимости от ваших потребностей. Ян перебирает все возможные варианты и рабочие характеристики каждого из них. В итоге он предлагает следующий наиболее оптимизированный метод, с помощью которого это можно сделать в MySQL select:

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;

HTH,

-Дипин

Для выбора нескольких случайных строк из данной таблицы (скажем, «слова») наша команда придумала такую ​​красоту:

SELECT * FROM
`words` AS r1 JOIN 
(SELECT  MAX(`WordID`) as wid_c FROM `words`) as tmp1
WHERE r1.WordID >= (SELECT (RAND() * tmp1.wid_c) AS id) LIMIT n

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

если вы не удаляете строку в этой таблице, наиболее эффективный способ:

(если вы знаете минимальный идентификатор, просто пропустите его)

SELECT MIN(id) AS minId, MAX(id) AS maxId FROM table WHERE 1

$randId=mt_rand((int)$row['minId'], (int)$row['maxId']);

SELECT id,name,... FROM table WHERE id=$randId LIMIT 1

Чтобы найти случайные строки из таблицы, не используйте ORDER BY RAND (), потому что он заставляет MySQL выполнять полную сортировку файла и только затем извлекать необходимое количество строк. Чтобы избежать этой полной сортировки файлов, используйте функцию RAND () только в предложении where. Он остановится, как только наберет необходимое количество строк. Видеть http://www.rndblog.com/how-to-select-random-rows-in-mysql/

Я столкнулся с проблемой, когда мои идентификаторы не были последовательными. Что я придумал это.

SELECT * FROM products WHERE RAND()<=(5/(SELECT COUNT(*) FROM products)) LIMIT 1

Возвращено примерно 5 строк, но я ограничиваю их до 1.

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

SELECT * FROM products WHERE RAND()<=(100/(SELECT COUNT(*) FROM pt_products)) AND discount<.2 LIMIT 1

Что вам нужно сделать, так это убедиться, что вы возвращаете достаточный результат, поэтому я установил его на 100. Наличие предложения WHERE Discount <.2 в подзапросе было в 10 раз медленнее, поэтому лучше возвращать больше результатов и лимит.

SELECT DISTINCT * FROM yourTable WHERE 4 = 4 LIMIT 1;

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

select a.* from random_data a, (select max(id)*rand() randid  from random_data) b
     where a.id >= b.randid limit 1;

Здесь id не обязательно должен быть последовательным. Это может быть любой столбец с первичным ключом / уникальный / автоинкремент. См. Следующий Самый быстрый способ выбрать случайную строку из большой таблицы MySQL

Спасибо Зиллур - www.techinfobest.com

Используйте приведенный ниже запрос, чтобы получить случайную строку

SELECT user_firstname ,
COUNT(DISTINCT usr_fk_id) cnt
FROM userdetails 
GROUP BY usr_fk_id 
ORDER BY cnt ASC  
LIMIT 1

В моем случае у моей таблицы есть идентификатор в качестве первичного ключа, автоинкремент без пробелов, поэтому я могу использовать COUNT(*) или MAX(id), чтобы получить количество строк.

Я сделал этот скрипт, чтобы проверить самую быструю операцию:

logTime();
query("SELECT COUNT(id) FROM tbl");
logTime();
query("SELECT MAX(id) FROM tbl");
logTime();
query("SELECT id FROM tbl ORDER BY id DESC LIMIT 1");
logTime();

Результаты следующие:

• Количество: 36.8418693542479 ms
• Макс: 0.241041183472 ms
• Приказ: 0.216960906982 ms

Ответьте с методом заказа:

SELECT FLOOR(RAND() * (
    SELECT id FROM tbl ORDER BY id DESC LIMIT 1
)) n FROM tbl LIMIT 1

...
SELECT * FROM tbl WHERE id = $result;

Я использовал это, и работа была сделана ссылка из здесь

SELECT * FROM myTable WHERE RAND()<(SELECT ((30/COUNT(*))*10) FROM myTable) ORDER BY RAND() LIMIT 30;

Создайте функцию, чтобы сделать это, скорее всего, это лучший ответ и самый быстрый ответ здесь!

Плюсы - Работает даже с пробелами и очень быстро.

<?

$sqlConnect = mysqli_connect('localhost','username','password','database');

function rando($data,$find,$max = '0'){
   global $sqlConnect; // Set as mysqli connection variable, fetches variable outside of function set as GLOBAL
   if ($data == 's1'){
     $query = mysqli_query($sqlConnect, "SELECT * FROM `yourtable` ORDER BY `id` DESC LIMIT {$find},1");

     $fetched_data = mysqli_fetch_assoc($query);
      if (mysqli_num_rows($fetched_data>0){
       return $fetch_$data;
      }else{
       rando('','',$max); // Start Over the results returned nothing
      }
   }else{
     if ($max != '0'){
        $irand = rand(0,$max); 
        rando('s1',$irand,$max); // Start rando with new random ID to fetch
     }else{

        $query = mysqli_query($sqlConnect, "SELECT `id` FROM `yourtable` ORDER BY `id` DESC LIMIT 0,1");
        $fetched_data = mysqli_fetch_assoc($query);
        $max = $fetched_data['id'];
        $irand = rand(1,$max);
        rando('s1',$irand,$max); // Runs rando against the random ID we have selected if data exist will return
     }
   }
 }

 $your_data = rando(); // Returns listing data for a random entry as a ASSOC ARRAY
?>

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