Dans MariaDB, RAND() est une fonction intégrée qui renvoie un DOUBLE aléatoire valeur en virgule flottante de précision v dans la plage 0 <= v < 1.0 .
Syntaxe
RAND() peut être utilisé des deux manières suivantes :
RAND()
RAND(N)
Où N est un entier constant à utiliser comme valeur de départ.
Lorsqu'une valeur de départ est utilisée, RAND() produit une séquence reproductible de valeurs de colonne.
Exemple
Voici un exemple pour démontrer RAND() sans spécifier de valeur de départ :
SELECT RAND();Résultat :
+---------------------+ | RAND() | +---------------------+ | 0.14470310708945908 | +---------------------+
Exemple – Avec une graine
Voici un exemple pour démontrer RAND() avec une valeur de départ :
SELECT RAND(3);Résultat :
+--------------------+ | RAND(3) | +--------------------+ | 0.9057697559760601 | +--------------------+
Nous ne pouvons pas réellement faire la différence lorsque nous utilisons l'exemple ci-dessus. Pour voir la différence, nous devons effectuer plusieurs appels de fonction en utilisant la même graine.
Comme ceci :
SELECT
RAND(3),
RAND(3),
RAND(3);Résultat :
+--------------------+--------------------+--------------------+ | RAND(3) | RAND(3) | RAND(3) | +--------------------+--------------------+--------------------+ | 0.9057697559760601 | 0.9057697559760601 | 0.9057697559760601 | +--------------------+--------------------+--------------------+
Nous pouvons voir que les trois appels ont abouti à la même valeur.
Voici ce qui se passe lorsque nous omettons la valeur de départ :
SELECT
RAND(),
RAND(),
RAND();Résultat :
+--------------------+---------------------+---------------------+ | RAND() | RAND() | RAND() | +--------------------+---------------------+---------------------+ | 0.7037061310407763 | 0.08442136466914915 | 0.31098846095706195 | +--------------------+---------------------+---------------------+
Chaque appel renvoie une valeur différente.
Entier aléatoire dans une plage
Nous pouvons combiner RAND() avec FLOOR() , ainsi que quelques calculs, pour renvoyer un entier aléatoire dans une plage.
La syntaxe pour ce faire est la suivante :
FLOOR(min_value + RAND() * (max_value - min_value +1))Ainsi, nous pourrions faire ce qui suit pour renvoyer un entier aléatoire entre 1 et 10 :
SELECT FLOOR(1 + RAND() * (10 - 1 +1));Résultat :
+---------------------------------+ | FLOOR(1 + RAND() * (10 - 1 +1)) | +---------------------------------+ | 6 | +---------------------------------+
Appelons-le un peu plus pour voir l'effet aléatoire :
SELECT
FLOOR(1 + RAND() * (10 - 1 +1)) AS r1,
FLOOR(1 + RAND() * (10 - 1 +1)) AS r2,
FLOOR(1 + RAND() * (10 - 1 +1)) AS r3,
FLOOR(1 + RAND() * (10 - 1 +1)) AS r4,
FLOOR(1 + RAND() * (10 - 1 +1)) AS r5,
FLOOR(1 + RAND() * (10 - 1 +1)) AS r6,
FLOOR(1 + RAND() * (10 - 1 +1)) AS r7,
FLOOR(1 + RAND() * (10 - 1 +1)) AS r8;Résultat :
+----+----+----+----+----+----+----+----+ | r1 | r2 | r3 | r4 | r5 | r6 | r7 | r8 | +----+----+----+----+----+----+----+----+ | 3 | 6 | 10 | 4 | 6 | 10 | 1 | 6 | +----+----+----+----+----+----+----+----+
Renvoyer des lignes aléatoires d'un tableau
RAND() peut être utilisé en conjonction avec un ORDER BY clause et la LIMIT mot-clé pour renvoyer des lignes aléatoires à partir d'une table de base de données :
SELECT
PetId,
PetName
FROM Pets
ORDER BY RAND()
LIMIT 5;Exemple de résultat :
+-------+---------+ | PetId | PetName | +-------+---------+ | 5 | Tweet | | 7 | Bark | | 1 | Fluffy | | 8 | Meow | | 3 | Scratch | +-------+---------+
Et si je le relance, j'obtiens ceci :
+-------+---------+ | PetId | PetName | +-------+---------+ | 3 | Scratch | | 8 | Meow | | 4 | Wag | | 7 | Bark | | 6 | Fluffy | +-------+---------+
Et ainsi de suite…
Cependant, gardez à l'esprit que cela est assez intensif et ne doit pas être utilisé sur des tables plus grandes. Voir Data Sampling:Techniques for Efficiently Finding a Random Row sur le site Web MariaDB pour des techniques plus adaptées aux grandes tables.
Graine non numérique
Voici un exemple de ce qui se passe lorsque nous fournissons une valeur de départ non numérique :
SELECT RAND('five');Résultat :
+---------------------+
| RAND('five') |
+---------------------+
| 0.15522042769493574 |
+---------------------+
1 row in set, 1 warning (0.000 sec) Voyons l'avertissement :
SHOW WARNINGS;Résultat :
+---------+------+-------------------------------------------+ | Level | Code | Message | +---------+------+-------------------------------------------+ | Warning | 1292 | Truncated incorrect INTEGER value: 'five' | +---------+------+-------------------------------------------+
En outre, cela a tendance à renvoyer le même résultat, quelle que soit la graine non numérique utilisée. Par exemple, si je lui lance différentes graines non numériques, j'obtiens le même résultat :
SELECT
RAND('one'),
RAND('two'),
RAND('three');Résultat :
+---------------------+---------------------+---------------------+
| RAND('one') | RAND('two') | RAND('three') |
+---------------------+---------------------+---------------------+
| 0.15522042769493574 | 0.15522042769493574 | 0.15522042769493574 |
+---------------------+---------------------+---------------------+
1 row in set, 3 warnings (0.000 sec)
Vérifiez les avertissements :
SHOW WARNINGS;Résultat :
+---------+------+--------------------------------------------+ | Level | Code | Message | +---------+------+--------------------------------------------+ | Warning | 1292 | Truncated incorrect INTEGER value: 'one' | | Warning | 1292 | Truncated incorrect INTEGER value: 'two' | | Warning | 1292 | Truncated incorrect INTEGER value: 'three' | +---------+------+--------------------------------------------+
Arguments nuls
RAND() renvoie la même valeur lorsque la graine est null :
SELECT
RAND(null),
RAND(null),
RAND(null);Résultat :
+---------------------+---------------------+---------------------+ | RAND(null) | RAND(null) | RAND(null) | +---------------------+---------------------+---------------------+ | 0.15522042769493574 | 0.15522042769493574 | 0.15522042769493574 | +---------------------+---------------------+---------------------+
Bien que, dans ce cas, il n'y ait pas d'avertissement.
Trop d'arguments
Appel de RAND() avec trop d'arguments génère une erreur :
SELECT RAND(1, 2);Résultat :
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'RAND'
