Comment demander une ligne aléatoire en SQL?

Comment puis-je demander une ligne aléatoire (ou aussi proche de vraiment aléatoire que possible) en SQL pur?

Voir cet article: SQL pour sélectionner une ligne aléatoire dans une table de base de données . Il passe par des méthodes pour le faire dans MySQL, PostgreSQL, Microsoft SQL Server, IBM DB2 et Oracle (ce qui suit est copié à partir de ce lien):

Sélectionnez une ligne aléatoire avec MySQL:

SELECT column FROM table
ORDER BY RAND()
LIMIT 1

Sélectionnez une ligne aléatoire avec PostgreSQL:

SELECT column FROM table
ORDER BY RANDOM()
LIMIT 1

Sélectionnez une ligne aléatoire avec Microsoft SQL Server:

SELECT TOP 1 column FROM table
ORDER BY NEWID()

Sélectionnez une ligne aléatoire avec IBM DB2

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

Sélectionnez un enregistrement aléatoire avec Oracle:

SELECT column FROM
( SELECT column FROM table
ORDER BY dbms_random.value )
WHERE rownum = 1

Des solutions comme Jeremies:

SELECT * FROM table ORDER BY RAND() LIMIT 1

fonctionnent, mais ils ont besoin d'une analyse séquentielle de toute la table (car la valeur aléatoire associée à chaque ligne doit être calculée - afin que la plus petite puisse être déterminée), ce qui peut être assez lent pour des tables même de taille moyenne. Ma recommandation serait d'utiliser une sorte de colonne numérique indexée (de nombreuses tables en ont comme clés primaires), puis d'écrire quelque chose comme:

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

Cela fonctionne en temps logarithmique, quelle que soit la taille de la table, s'il num_valueest indexé. Une mise en garde: cela suppose qu'il num_valueest également distribué dans la plage 0..MAX(num_value). Si votre jeu de données s'écarte fortement de cette hypothèse, vous obtiendrez des résultats asymétriques (certaines lignes apparaîtront plus souvent que d'autres).

Je ne sais pas à quel point c'est efficace, mais je l'ai déjà utilisé:

SELECT TOP 1 * FROM MyTable ORDER BY newid()

Étant donné que les GUID sont assez aléatoires, la commande signifie que vous obtenez une ligne aléatoire.

ORDER BY NEWID()

prend 7.4 milliseconds

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

prend 0.0065 milliseconds!

J'irai certainement avec cette dernière méthode.

Vous n'avez pas dit quel serveur vous utilisez. Dans les anciennes versions de SQL Server, vous pouvez utiliser ceci:

select top 1 * from mytable order by newid()

Dans SQL Server 2005 et versions ultérieures, vous pouvez utiliser TABLESAMPLEpour obtenir un échantillon aléatoire répétable:

SELECT FirstName, LastName
FROM Contact 
TABLESAMPLE (1 ROWS) ;

Pour SQL Server

newid () / order by fonctionnera, mais sera très coûteux pour les grands ensembles de résultats car il doit générer un identifiant pour chaque ligne, puis les trier.

TABLESAMPLE () est bon du point de vue des performances, mais vous obtiendrez un agrégat de résultats (toutes les lignes d'une page seront retournées).

Pour un véritable échantillon aléatoire plus performant, la meilleure façon est de filtrer les lignes de manière aléatoire. J'ai trouvé l'exemple de code suivant dans l'article de documentation en ligne de SQL Server Limiter les ensembles de résultats à l'aide de TABLESAMPLE :

Si vous voulez vraiment un échantillon aléatoire de lignes individuelles, modifiez votre requête pour filtrer les lignes au hasard, au lieu d'utiliser TABLESAMPLE. Par exemple, la requête suivante utilise la fonction NEWID pour renvoyer environ un pour cent des lignes de la table Sales.SalesOrderDetail:

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

La colonne SalesOrderID est incluse dans l'expression CHECKSUM afin que NEWID () évalue une fois par ligne pour réaliser l'échantillonnage sur une ligne. L'expression CAST (CHECKSUM (NEWID (), SalesOrderID) & 0x7fffffff AS float / CAST (0x7fffffff AS int) est évaluée comme une valeur flottante aléatoire comprise entre 0 et 1.

Lorsqu'il est exécuté sur une table avec 1 000 000 lignes, voici mes résultats:

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

Si vous pouvez vous en tirer avec TABLESAMPLE, cela vous donnera les meilleures performances. Sinon, utilisez la méthode newid () / filter. newid () / order by devrait être le dernier recours si vous avez un grand ensemble de résultats.

Si possible, utilisez des instructions stockées pour éviter l'inefficacité des deux index sur RND () et créer un champ de numéro d'enregistrement.

PREPARE RandomRecord FROM "SELECT * FROM table LIMIT?, 1";
SET @ n = FLOOR (RAND () * (SELECT COUNT (*) FROM table));
EXECUTE RandomRecord USING @n;

La meilleure façon est de mettre une valeur aléatoire dans une nouvelle colonne juste à cette fin, et d'utiliser quelque chose comme ça (pseude code + SQL):

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

C'est la solution employée par le code MediaWiki. Bien sûr, il existe un certain biais par rapport aux valeurs plus petites, mais ils ont constaté qu'il suffisait d'enrouler la valeur aléatoire à zéro lorsqu'aucune ligne n'est extraite.

La solution newid () peut nécessiter une analyse complète de la table afin que chaque ligne puisse se voir attribuer un nouveau guid, qui sera beaucoup moins performant.

La solution rand () peut ne pas fonctionner du tout (c'est-à-dire avec MSSQL) car la fonction sera évaluée une seule fois et chaque ligne se verra attribuer le même numéro "aléatoire".

Pour SQL Server 2005 et 2008, si nous voulons un échantillon aléatoire de lignes individuelles (à partir de la documentation en ligne ):

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

Au lieu d' utiliser RAND (), comme cela n'est pas recommandé , vous pouvez simplement obtenir un ID max (= Max):

SELECT MAX(ID) FROM TABLE;

obtenir un aléatoire entre 1..Max (= My_Generated_Random)

My_Generated_Random = rand_in_your_programming_lang_function(1..Max);

puis exécutez ce SQL:

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

Notez qu'il vérifiera toutes les lignes dont les ID sont ÉGAUX ou SUPÉRIEURS à la valeur choisie. Il est également possible de rechercher la ligne dans le tableau et d'obtenir un ID égal ou inférieur à My_Generated_Random, puis de modifier la requête comme suit:

SELECT ID FROM TABLE WHERE ID <= My_Generated_Random ORDER BY ID DESC LIMIT 1

Comme indiqué dans le commentaire de @ BillKarwin sur la réponse de @ cnu ...

Lors de la combinaison avec un LIMIT, j'ai trouvé qu'il fonctionne beaucoup mieux (au moins avec PostgreSQL 9.1) pour JOIN avec un ordre aléatoire plutôt que pour ordonner directement les lignes réelles: par exemple

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

Assurez-vous simplement que le «r» génère une valeur «rand» pour chaque valeur de clé possible dans la requête complexe qui lui est associée, mais limitez toujours le nombre de lignes de «r» dans la mesure du possible.

Le CAST en tant qu'entier est particulièrement utile pour PostgreSQL 9.2 qui a une optimisation de tri spécifique pour les types flottants entiers et simple précision.

La plupart des solutions ici visent à éviter le tri, mais elles doivent toujours effectuer une analyse séquentielle sur une table.

Il existe également un moyen d'éviter le balayage séquentiel en passant au balayage d'index. Si vous connaissez la valeur d'index de votre ligne aléatoire, vous pouvez obtenir le résultat presque instantanément. Le problème est - comment deviner une valeur d'index.

La solution suivante fonctionne sur 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;

I solution ci-dessus, vous devinez 10 différentes valeurs d'index aléatoires de la plage 0 .. [dernière valeur de id].

Le nombre 10 est arbitraire - vous pouvez utiliser 100 ou 1000 car cela (étonnamment) n'a pas un grand impact sur le temps de réponse.

Il y a aussi un problème - si vous avez des identifiants clairsemés, vous pourriez manquer . La solution est d' avoir un plan de sauvegarde :) Dans ce cas, un pur ancien ordre par requête random (). Lorsque l'ID combiné ressemble à ceci:

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;

Pas la clause union ALL . Dans ce cas, si la première partie renvoie des données, la seconde n'est JAMAIS exécutée!

En retard, mais arrivé ici via Google, donc pour la postérité, je vais ajouter une solution alternative.

Une autre approche consiste à utiliser TOP deux fois, avec des ordres alternés. Je ne sais pas s'il s'agit de "SQL pur", car il utilise une variable dans le TOP, mais il fonctionne dans SQL Server 2008. Voici un exemple que j'utilise par rapport à un tableau de mots de dictionnaire, si je veux un mot aléatoire.

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

Bien sûr, @idx est un entier généré de manière aléatoire qui va de 1 à COUNT (*) sur la table cible, inclusivement. Si votre colonne est indexée, vous en profiterez également. Un autre avantage est que vous pouvez l'utiliser dans une fonction, car NEWID () n'est pas autorisé.

Enfin, la requête ci-dessus s'exécute dans environ 1/10 du temps d'exécution d'une requête de type NEWID () sur la même table. YYMV.

Vous pouvez également essayer d'utiliser la new id()fonction.

Écrivez simplement votre requête et utilisez l'ordre par new id()fonction. C'est assez aléatoire.

Pour MySQL pour obtenir un enregistrement aléatoire

 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

Plus de détails http://jan.kneschke.de/projects/mysql/order-by-rand/

Je n'ai pas encore tout à fait vu cette variation dans les réponses. J'avais une contrainte supplémentaire là où j'avais besoin, étant donné une graine initiale, de sélectionner le même ensemble de lignes à chaque fois.

Pour MS SQL:

Exemple minimum:

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

Temps d'exécution normalisé: 1,00

Exemple avec NewId ():

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

Temps d'exécution normalisé: 1,02

NewId()est insignifiamment plus lent que rand(checksum(*)), donc vous ne voudrez peut-être pas l'utiliser contre de grands jeux d'enregistrements.

Sélection avec semence initiale:

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 */

Si vous devez sélectionner le même ensemble en fonction d'une graine, cela semble fonctionner.

Dans MSSQL (testé le 11.0.5569) en utilisant

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

est nettement plus rapide que

SELECT TOP 100 * FROM employee ORDER BY NEWID()

Dans SQL Server, vous pouvez combiner TABLESAMPLE avec NEWID () pour obtenir un assez bon caractère aléatoire et toujours avoir de la vitesse. Ceci est particulièrement utile si vous ne voulez vraiment que 1 ou un petit nombre de lignes.

SELECT TOP 1 * FROM [table] 
TABLESAMPLE (500 ROWS) 
ORDER BY NEWID()

Avec SQL Server 2012+, vous pouvez utiliser la requête OFFSET FETCH pour le faire pour une seule ligne aléatoire

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

où id est une colonne d'identité et n est la ligne que vous voulez - calculée comme un nombre aléatoire entre 0 et count () - 1 de la table (le décalage 0 est la première ligne après tout)

Cela fonctionne avec des trous dans les données de la table, tant que vous disposez d'un index avec lequel travailler pour la clause ORDER BY. C'est aussi très bon pour le caractère aléatoire - car vous travaillez vous-même pour passer, mais les inconvénients des autres méthodes ne sont pas présents. De plus, les performances sont assez bonnes, sur un ensemble de données plus petit, elles résistent bien, même si je n'ai pas essayé de tests de performances sérieux contre plusieurs millions de lignes.

 SELECT * FROM table ORDER BY RAND() LIMIT 1

Je dois être d'accord avec CD-MaN: L'utilisation de "ORDER BY RAND ()" fonctionnera bien pour les petites tables ou lorsque vous effectuez votre SELECT seulement quelques fois.

J'utilise également la technique "num_value> = RAND () * ...", et si je veux vraiment avoir des résultats aléatoires, j'ai une colonne "aléatoire" spéciale dans le tableau que je mets à jour une fois par jour environ. Cette exécution unique de MISE À JOUR prendra un certain temps (en particulier parce que vous devrez avoir un index sur cette colonne), mais c'est beaucoup plus rapide que de créer des nombres aléatoires pour chaque ligne à chaque exécution de la sélection.

Soyez prudent car TableSample ne retourne pas réellement un échantillon aléatoire de lignes. Il dirige votre requête pour regarder un échantillon aléatoire des pages de 8 Ko qui composent votre ligne. Ensuite, votre requête est exécutée par rapport aux données contenues dans ces pages. En raison de la façon dont les données peuvent être regroupées sur ces pages (ordre d'insertion, etc.), cela pourrait conduire à des données qui ne sont pas réellement un échantillon aléatoire.

Voir: http://www.mssqltips.com/tip.asp?tip=1308

Cette page MSDN pour TableSample comprend un exemple de la façon de générer un échantillon de données réellement aléatoire.

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

Il semble que bon nombre des idées énumérées utilisent encore la commande

Cependant, si vous utilisez une table temporaire, vous pouvez attribuer un index aléatoire (comme la plupart des solutions l'ont suggéré), puis récupérer le premier qui est supérieur à un nombre arbitraire entre 0 et 1.

Par exemple (pour DB2):

WITH TEMP AS (
SELECT COMLUMN, RAND() AS IDX FROM TABLE)
SELECT COLUMN FROM TABLE WHERE IDX > .5
FETCH FIRST 1 ROW ONLY

Un moyen simple et efficace de 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;

Il existe une meilleure solution pour Oracle au lieu d'utiliser dbms_random.value, alors qu'elle nécessite une analyse complète pour ordonner les lignes par dbms_random.value et elle est assez lente pour les grandes tables.

Utilisez-le à la place:

SELECT *
FROM employee sample(1)
WHERE rownum=1

Pour Firebird:

Select FIRST 1 column from table ORDER BY RAND()

Pour SQL Server 2005 et supérieur, étendre la réponse de @ GreyPanther aux cas où num_valuen'a pas de valeurs continues. Cela fonctionne aussi pour les cas où nous n'avons pas réparti les ensembles de données de manière égale et quand il num_valuene s'agit pas d'un nombre mais d'un identifiant unique.

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

Une fonction aléatoire du sql pourrait aider. De plus, si vous souhaitez limiter à une seule ligne, ajoutez simplement cela à la fin.

SELECT column FROM table
ORDER BY RAND()
LIMIT 1