MariaDB BENCHMARK() Explicado

No MariaDB, BENCHMARK() é uma função interna que executa uma expressão um número especificado de vezes.

Ele pode ser usado para cronometrar a rapidez com que o MariaDB processa a expressão.

O resultado é sempre 0 . A função deve ser usada na ferramenta de linha de comando mysql, que informa os tempos de execução da consulta.

Sintaxe

A sintaxe fica assim:

BENCHMARK(count,expr)

Onde count é o número de vezes que você deseja expr para correr.

Exemplo 1

Segue um exemplo para demonstrar:

SELECT BENCHMARK(2, SLEEP(2));

Resultado:

+------------------------+
| BENCHMARK(2, SLEEP(2)) |
+------------------------+
|                      0 |
+------------------------+
1 row in set (4.015 sec)

Como esperado, 0 foi devolvido. No entanto, o que nos interessa é o tempo de execução da consulta.

Aqui eu usei o SLEEP() função para dormir por 2 segundos. Usar essa função por si só normalmente faria com que a instrução levasse cerca de 2 segundos para ser executada.

No entanto, neste caso eu passei 2 como o primeiro argumento para BENCHMARK() . Isso fez com que o SLEEP() função para executar duas vezes, fazendo com que o BENCHMARK() função para levar cerca de 4 segundos para executar (4,015 segundos para ser preciso).

Veja o que acontece se aumentarmos o primeiro argumento para 3 :

SELECT BENCHMARK(3, SLEEP(2));

Resultado:

+------------------------+
| BENCHMARK(3, SLEEP(2)) |
+------------------------+
|                      0 |
+------------------------+
1 row in set (6.012 sec)

Desta vez, o SLEEP() função foi executada três vezes, então BENCHMARK() levou pouco mais de 6 segundos para ser executado.

Exemplo 2

Aqui está um exemplo que usa o ENCODE() função para codificar uma string (primeiro argumento) com uma senha (segundo argumento):

SELECT BENCHMARK(100000, ENCODE('Homer', 'Symptom'));

Resultado:

+-----------------------------------------------+
| BENCHMARK(100000, ENCODE('Homer', 'Symptom')) |
+-----------------------------------------------+
|                                             0 |
+-----------------------------------------------+
1 row in set (0.016 sec)

Podemos ver que a operação levou 0,016 segundos para ser concluída.

Vamos aumentar o primeiro argumento de 100.000 para 1.000.000 e ver como isso afeta o tempo de execução.

SELECT BENCHMARK(1000000, ENCODE('Homer', 'Symptom'));

Resultado:

+------------------------------------------------+
| BENCHMARK(1000000, ENCODE('Homer', 'Symptom')) |
+------------------------------------------------+
|                                              0 |
+------------------------------------------------+
1 row in set (0.118 sec)

Desta vez demorou muito mais para correr.

Argumento nulo

Se o primeiro argumento for null , então null é retornado:

SELECT BENCHMARK(null, ENCODE('Homer', 'Symptom'));

Resultado:

+---------------------------------------------+
| BENCHMARK(null, ENCODE('Homer', 'Symptom')) |
+---------------------------------------------+
|                                        NULL |
+---------------------------------------------+
1 row in set (0.007 sec)

Mas se apenas o segundo argumento for null , então 0 é retornado:

SELECT BENCHMARK(100000, null);

Resultado:

+-------------------------+
| BENCHMARK(100000, null) |
+-------------------------+
|                       0 |
+-------------------------+
1 row in set (0.002 sec)

Número inválido de argumentos

Chamando BENCHMARK() sem argumentos, ou com o número errado de argumentos, resulta em um erro:

SELECT BENCHMARK();

Resultado:

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

SELECT BENCHMARK(1, 2, 3);

Resultado:

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