Como RAND() funciona no MariaDB

No MariaDB, RAND() é uma função interna que retorna um DOUBLE aleatório valor de ponto flutuante de precisão v no intervalo 0 <= v < 1.0 .

Sintaxe

RAND() pode ser usado das duas maneiras a seguir:

RAND()
RAND(N)

Onde N é um inteiro constante a ser usado como um valor de semente.

Quando um valor de semente é usado, RAND() produz uma sequência repetível de valores de coluna.

Exemplo

Aqui está um exemplo para demonstrar RAND() sem especificar um valor de semente:

SELECT RAND();

Resultado:

+---------------------+
| RAND()              |
+---------------------+
| 0.14470310708945908 |
+---------------------+

Exemplo – Com uma semente

Aqui está um exemplo para demonstrar RAND() com um valor de semente:

SELECT RAND(3);

Resultado:

+--------------------+
| RAND(3)            |
+--------------------+
| 0.9057697559760601 |
+--------------------+

Na verdade, não podemos dizer a diferença ao usar o exemplo acima. Para ver a diferença, precisamos fazer várias chamadas de função usando a mesma semente.

Assim:

SELECT 
    RAND(3),
    RAND(3),
    RAND(3);

Resultado:

+--------------------+--------------------+--------------------+
| RAND(3)            | RAND(3)            | RAND(3)            |
+--------------------+--------------------+--------------------+
| 0.9057697559760601 | 0.9057697559760601 | 0.9057697559760601 |
+--------------------+--------------------+--------------------+

Podemos ver que todas as três chamadas resultaram no mesmo valor.

Veja o que acontece quando omitimos o valor da semente:

SELECT 
    RAND(),
    RAND(),
    RAND();

Resultado:

+--------------------+---------------------+---------------------+
| RAND()             | RAND()              | RAND()              |
+--------------------+---------------------+---------------------+
| 0.7037061310407763 | 0.08442136466914915 | 0.31098846095706195 |
+--------------------+---------------------+---------------------+

Cada chamada retorna um valor diferente.

Inteiro aleatório dentro de um intervalo

Podemos combinar RAND() com FLOOR() , juntamente com alguns cálculos, para retornar um número inteiro aleatório dentro de um intervalo.

A sintaxe para fazer isso é assim:

FLOOR(min_value + RAND() * (max_value - min_value +1))

Então, poderíamos fazer o seguinte para retornar um inteiro aleatório entre 1 e 10:

SELECT FLOOR(1 + RAND() * (10 - 1 +1));

Resultado:

+---------------------------------+
| FLOOR(1 + RAND() * (10 - 1 +1)) |
+---------------------------------+
|                               6 |
+---------------------------------+

Vamos chamá-lo um pouco mais para ver o efeito aleatório:

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;

Resultado:

+----+----+----+----+----+----+----+----+
| r1 | r2 | r3 | r4 | r5 | r6 | r7 | r8 |
+----+----+----+----+----+----+----+----+
|  3 |  6 | 10 |  4 |  6 | 10 |  1 |  6 |
+----+----+----+----+----+----+----+----+

Retornar linhas aleatórias de uma tabela

RAND() pode ser usado em conjunto com um ORDER BY cláusula e o LIMIT palavra-chave para retornar linhas aleatórias de uma tabela de banco de dados:

SELECT  
    PetId,
    PetName
FROM Pets 
ORDER BY RAND() 
LIMIT 5;

Exemplo de resultado:

+-------+---------+
| PetId | PetName |
+-------+---------+
|     5 | Tweet   |
|     7 | Bark    |
|     1 | Fluffy  |
|     8 | Meow    |
|     3 | Scratch |
+-------+---------+

E se eu executar novamente, recebo isso:

+-------+---------+
| PetId | PetName |
+-------+---------+
|     3 | Scratch |
|     8 | Meow    |
|     4 | Wag     |
|     7 | Bark    |
|     6 | Fluffy  |
+-------+---------+

E assim por diante…

No entanto, tenha em mente que isso é bastante intensivo e não deve ser usado em tabelas maiores. Consulte Amostragem de dados:técnicas para encontrar com eficiência uma linha aleatória no site do MariaDB para obter técnicas mais adequadas para tabelas maiores.

Semente não numérica

Aqui está um exemplo do que acontece quando fornecemos um valor de semente não numérico:

SELECT RAND('five');

Resultado:

+---------------------+
| RAND('five')        |
+---------------------+
| 0.15522042769493574 |
+---------------------+
1 row in set, 1 warning (0.000 sec)

Vejamos o aviso:

SHOW WARNINGS;

Resultado:

+---------+------+-------------------------------------------+
| Level   | Code | Message                                   |
+---------+------+-------------------------------------------+
| Warning | 1292 | Truncated incorrect INTEGER value: 'five' |
+---------+------+-------------------------------------------+

Além disso, isso tende a retornar o mesmo resultado, independentemente de qual semente não numérica é usada. Por exemplo, se eu jogar diferentes sementes não numéricas nele, recebo o mesmo resultado:

SELECT 
    RAND('one'),
    RAND('two'),
    RAND('three');

Resultado:

+---------------------+---------------------+---------------------+
| RAND('one')         | RAND('two')         | RAND('three')       |
+---------------------+---------------------+---------------------+
| 0.15522042769493574 | 0.15522042769493574 | 0.15522042769493574 |
+---------------------+---------------------+---------------------+
1 row in set, 3 warnings (0.000 sec)

Confira os avisos:

SHOW WARNINGS;

Resultado:

+---------+------+--------------------------------------------+
| Level   | Code | Message                                    |
+---------+------+--------------------------------------------+
| Warning | 1292 | Truncated incorrect INTEGER value: 'one'   |
| Warning | 1292 | Truncated incorrect INTEGER value: 'two'   |
| Warning | 1292 | Truncated incorrect INTEGER value: 'three' |
+---------+------+--------------------------------------------+

Argumentos nulos

RAND() retorna o mesmo valor quando a semente é null :

SELECT 
    RAND(null),
    RAND(null),
    RAND(null);

Resultado:

+---------------------+---------------------+---------------------+
| RAND(null)          | RAND(null)          | RAND(null)          |
+---------------------+---------------------+---------------------+
| 0.15522042769493574 | 0.15522042769493574 | 0.15522042769493574 |
+---------------------+---------------------+---------------------+

Embora, neste caso, não haja avisos.

Muitos argumentos

Chamando RAND() com muitos argumentos resulta em um erro:

SELECT RAND(1, 2);

Resultado:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'RAND'