la sélection rapide d'une ligne au hasard à partir d'une grande table dans mysql

Je savais qu'il y avait un moyen de le faire en une seule requête dans une voie rapide. Et c'est ici:

Un moyen rapide, sans engagement de code externe, bravo à

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;

OriginalL'auteur Vinko Vrsalovic

Voici une solution qui fonctionne assez rapidement, et on obtient une meilleure distribution aléatoire sans en fonction des valeurs d'id d'être contigus ou en commençant à 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;

OriginalL'auteur Bill Karwin

Ajouter une colonne contenant un calculés valeur aléatoire à chaque ligne, et de l'utiliser dans la commande de la clause, en limitant à un résultat au moment de la sélection. Cela fonctionne plus rapidement que d'avoir la table d'analyse que ORDER BY RANDOM() causes.

Mise à jour: Vous avez encore besoin de calculer certains aléatoire de la valeur avant l'émission de la SELECT déclaration lors de la récupération, bien sûr, par exemple,

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

OriginalL'auteur Rob

En pseudo code:

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

Cela suppose que id est unique (primaire).

OriginalL'auteur Anders Sandvig

Afin de trouver des lignes aléatoires à partir d'une table, ne pas utiliser ORDER BY RAND() car les forces de MySQL pour faire un fichier de tri et seulement ensuite pour récupérer la limite de nombre de lignes nécessaires. Afin d'éviter ce fichier complet trier, utiliser la fonction RAND() seulement à la clause where. Il s'arrêtera dès qu'il atteint le nombre requis de lignes.
Voir
http://www.rndblog.com/how-to-select-random-rows-in-mysql/

OriginalL'auteur Sagi Bron

Pour la sélection de plusieurs lignes aléatoires à partir d'une table donnée (disons "mots"), notre équipe est venu avec cette beauté:

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

OriginalL'auteur

Avec un ordre yo va faire un balayage complet de la table.
Son meilleur si vous faites un select count(*) et, plus tard, d'obtenir une ligne aléatoire=rownum entre 0 et le dernier registre

OriginalL'auteur MazarD

Je suis un peu nouveau pour SQL mais comment sur la génération d'un nombre aléatoire en PHP et utilisant

SELECT * FROM the_table WHERE primary_key >= $randNr

cela ne résout pas le problème avec les trous de la table.

Mais voici une torsion sur lassevks suggestion:

SELECT primary_key FROM the_table

Utiliser mysql_num_rows() en PHP créer un nombre aléatoire basé sur le résultat ci-dessus:

SELECT * FROM the_table WHERE primary_key = rand_number

Sur une note de côté, juste la lenteur est SELECT * FROM the_table:

La création d'un nombre aléatoire basé sur mysql_num_rows(), puis en déplaçant le pointeur de données à ce point mysql_data_seek(). Juste comment ralentir ce que ce sera sur les grandes tables à dire un million de lignes?

OriginalL'auteur

Je vois ici beaucoup de solution. Un ou deux semble ok, mais les autres solutions ont certaines contraintes. Mais la suite de la solution pour l'ensemble de la situation

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

Ici, l'id n'a pas besoin d'être séquentielle. Il pourrait être une clé primaire/unique/auto incrémentée. Veuillez voir la suite Moyen le plus rapide pour sélectionner une ligne au hasard à partir d'une grande table MySQL

Merci
Zillur
- http://www.techinfobest.com

OriginalL'auteur Zillur

Dans mon cas, ma table a un id comme clé primaire auto-incrémentée avec pas de lacunes, de sorte que je peux utiliser COUNT(*) ou MAX(id) pour obtenir le nombre de lignes.

J'ai fait ce script pour tester la manière la plus rapide de l'opération:

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();

Les résultats sont les suivants:

• Count: 36.8418693542479 ms
• Max: 0.241041183472 ms
• Ordre: 0.216960906982 ms

Réponse avec la méthode de l'ordre:

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

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

OriginalL'auteur Toni Almeida

Créer une Fonction pour ce faire probablement la meilleure réponse et la plus rapide de réponse ici!

Pros - Fonctionne même avec des Lacunes et extrêmement rapide.

<?

$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
?>

Veuillez garder à l'esprit ce code n'a pas été testé, mais est un concept de travail à rendement aléatoire des entrées, même avec des lacunes.. tant Que les écarts ne sont pas énormes assez pour causer un temps de chargement de la question.

OriginalL'auteur RandomGuest

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

OriginalL'auteur proggL