MariaDB BENCHMARK() expliqué

Dans MariaDB, BENCHMARK() est une fonction intégrée qui exécute une expression un nombre de fois spécifié.

Il peut être utilisé pour chronométrer la rapidité avec laquelle MariaDB traite l'expression.

Le résultat est toujours 0 . La fonction est destinée à être utilisée dans l'outil de ligne de commande mysql, qui signale les temps d'exécution des requêtes.

Syntaxe

La syntaxe ressemble à ceci :

BENCHMARK(count,expr)

Où count est le nombre de fois que vous voulez expr courir.

Exemple 1

Voici un exemple pour illustrer :

SELECT BENCHMARK(2, SLEEP(2));

Résultat :

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

Comme prévu, 0 a été retourné. Cependant, ce qui nous intéresse, c'est le temps d'exécution de la requête.

Ici, j'ai utilisé le SLEEP() fonction pour dormir pendant 2 secondes. L'utilisation de cette fonction seule entraînerait normalement l'exécution de l'instruction pendant environ 2 secondes.

Cependant, dans ce cas, j'ai passé 2 comme premier argument de BENCHMARK() . Cela a causé le SLEEP() fonction à exécuter deux fois, provoquant le BENCHMARK() fonction prend environ 4 secondes pour s'exécuter (4,015 secondes pour être précis).

Voici ce qui se passe si nous augmentons le premier argument à 3 :

SELECT BENCHMARK(3, SLEEP(2));

Résultat :

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

Cette fois, le SLEEP() la fonction a été exécutée trois fois, et donc BENCHMARK() a pris un peu plus de 6 secondes pour s'exécuter.

Exemple 2

Voici un exemple qui utilise le ENCODE() fonction pour coder une chaîne (premier argument) avec un mot de passe (deuxième argument) :

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

Résultat :

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

Nous pouvons voir que l'opération a duré 0,016 seconde.

Augmentons le premier argument de 100 000 à 1 000 000 et voyons comment cela affecte le temps d'exécution.

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

Résultat :

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

Cette fois, l'exécution a pris beaucoup plus de temps.

Argument nul

Si le premier argument est null , puis null est renvoyé :

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

Résultat :

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

Mais si seul le deuxième argument est null , puis 0 est renvoyé :

SELECT BENCHMARK(100000, null);

Résultat :

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

Nombre d'arguments invalide

Appel de BENCHMARK() sans arguments, ou avec un nombre d'arguments erroné, génère une erreur :

SELECT BENCHMARK();

Résultat :

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

Et :

SELECT BENCHMARK(1, 2, 3);

Résultat :

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