# Statistiques

Le pilote natif MySQL contient un support pour la collecte de statistiques sur la communication entre le client et le serveur. Les statistiques collectées sont de deux types principaux :

- Statistiques du client
- Statistiques de la connexion

Lorsque l'extension mysqli est utilisée, ces statistiques peuvent être obtenues via deux appels API :

- mysqli_get_client_stats()
- mysqli_get_connection_stats()

> Note: Les statistiques sont agrégées parmi toutes les extensions qui utilisent le pilote natif MySQL. Par exemple, si l'extension mysqli et le pilote PDO MySQL sont tous deux configurés pour utiliser MySQLnd, alors les appels de fonctions de mysqli et les appels de méthodes de PDO affecteront les statistiques. Il n'y a aucun moyen de savoir combien un certain appel d'API d'une extension qui a été compilée sans le pilote natif MySQL a impacté une certaine statistique.

## Récupération des statistiques

Les statistiques du client peuvent être récupérées en appelant la fonction mysqli_get_client_stats().

Les statistiques de connexion peuvent être récupérées en appelant la fonction mysqli_get_connection_stats().

Les deux fonctions retournent un tableau associatif, où le nom d'une statistique est la clé pour les données statistiques correspondantes.

## Statistiques du pilote natif MySQL

La plupart des statistiques sont associées à une connexion, mais certaines sont associées au processus, auquel cas cela sera mentionné.

Les statistiques suivantes sont produites par le pilote natif MySQL :

Statistiques liées au réseau
`bytes_sent`
  Le nombre d'octets envoyés de PHP au serveur MySQL.
`bytes_received`
  Le nombre d'octets reçus du serveur MySQL.
`packets_sent`
  Le nombre de paquets envoyés par le protocole client-serveur MySQL.
`packets_received`
  Le nombre de paquets reçus du protocole client-serveur MySQL.
`protocol_overhead_in`
  Le surdébit du protocole client-serveur MySQL en octets pour le trafic entrant. Actuellement, seul l'en-tête de paquet (4 octets) est considéré comme un surdébit. `protocol_overhead_in = packets_received * 4`
`protocol_overhead_out`
  Le surdébit du protocole client-serveur MySQL en octets pour le trafic sortant. Actuellement, seul l'en-tête de paquet (4 octets) est considéré comme un surdébit. `protocol_overhead_out = packets_received * 4`
`bytes_received_ok_packet`
  La taille totale en octets des paquets OK du protocole client-serveur MySQL reçus. Les paquets OK peuvent contenir un message d'état. La longueur du message d'état peut varier et donc la taille d'un paquet OK n'est pas fixe.

  > Note: La taille totale en octets inclut la taille de l'en-tête du paquet (4 octets, voir le surdébit du protocole).

`packets_received_ok`
  Le nombre de paquets OK du protocole client-serveur MySQL reçus.
`bytes_received_eof_packet`
  La taille totale en octets des paquets EOF du protocole client-serveur MySQL reçus. La taille d'un paquet EOF peut varier en fonction de la version du serveur. De plus, un paquet EOF peut transporter un message d'erreur.

  > Note: La taille totale en octets inclut la taille de l'en-tête du paquet (4 octets, voir le surdébit du protocole).

`packets_received_eof`
  Le nombre de paquets EOF du protocole client-serveur MySQL reçus. Comme pour d'autres statistiques de paquets, le nombre de paquets sera augmenté même si PHP ne reçoit pas le paquet attendu mais, par exemple, un message d'erreur.
`bytes_received_rset_header_packet`
  La taille totale en octets des en-têtes de paquets de résultats du protocole client-serveur MySQL reçus. La taille de l'en-tête de paquet peut varier en fonction de la charge utile (`LOAD LOCAL INFILE`, `INSERT`, `UPDATE`, `SELECT`, message d'erreur).

  > Note: La taille totale en octets inclut la taille de l'en-tête du paquet (4 octets, voir le surdébit du protocole).

`packets_received_rset_header`
  Le nombre de paquets d'en-têtes de résultats du protocole client-serveur MySQL reçus.
`bytes_received_rset_field_meta_packet`
  La taille totale en octets des paquets de métadonnées de résultats du protocole client-serveur (informations de champ). Bien sûr, la taille varie avec les champs du résultat. Le paquet peut également transporter une erreur ou un paquet EOF en cas de COM_LIST_FIELDS.

  > Note: La taille totale en octets inclut la taille de l'en-tête du paquet (4 octets, voir le surdébit du protocole).

`packets_received_rset_field_meta`
  Le nombre de paquets de métadonnées de résultats du protocole client-serveur reçus (informations de champ).
`bytes_received_rset_row_packet`
  La taille totale en octets des données de ligne de résultats du protocole client-serveur MySQL reçues. Le paquet peut également transporter une erreur ou un paquet EOF. On peut calculer le nombre d'erreurs et de paquets EOF en soustrayant `rows_fetched_from_server_normal` et `rows_fetched_from_server_ps` de `bytes_received_rset_row_packet`.

  > Note: La taille totale en octets inclut la taille de l'en-tête du paquet (4 octets, voir le surdébit du protocole).

`packets_received_rset_row`
  Le nombre de paquets de données de ligne de résultats du protocole client-serveur MySQL reçus.
`bytes_received_prepare_response_packet`
  La taille totale en octets des paquets OK du protocole client-serveur MySQL reçus pour l'initialisation des déclarations préparées (paquets d'initialisation de déclaration préparée). Le paquet peut également transporter une erreur. La taille du paquet dépend de la version de MySQL.

  > Note: La taille totale en octets inclut la taille de l'en-tête du paquet (4 octets, voir le surdébit du protocole).

`packets_received_prepare_response`
  Le nombre de paquets OK du protocole client-serveur MySQL reçus pour l'initialisation des déclarations préparées (paquets d'initialisation de déclaration préparée).
`bytes_received_change_user_packet`
  La taille totale en octets des paquets COM_CHANGE_USER du protocole client-serveur MySQL reçus. Le paquet peut également transporter une erreur ou un paquet EOF.

  > Note: La taille totale en octets inclut la taille de l'en-tête du paquet (4 octets, voir le surdébit du protocole).

`packets_received_change_user`
  Le nombre de paquets COM_CHANGE_USER du protocole client-serveur MySQL reçus.
`packets_sent_command`
  Le nombre de commandes MySQL envoyées par PHP au serveur MySQL. Il n'y a aucun moyen de savoir quelles commandes spécifiques et combien d'entre elles ont été envoyées.
`bytes_received_real_data_normal`
  Le nombre d'octets de charge utile récupérés par le client PHP depuis `mysqlnd` en utilisant le protocole texte. Ceci est la taille des données réelles contenues dans les ensembles de résultats qui ne proviennent pas de déclarations préparées et qui ont été récupérées par le client PHP. Il est à noter que bien qu'un ensemble de résultats complet ait pu être extrait de MySQL par `mysqlnd`, cette statistique ne compte que les données réelles extraites de `mysqlnd` par le client PHP.

  Un exemple de séquence de code qui augmentera la valeur est le suivant :

      $mysqli = new mysqli();
      $res = $mysqli->query("SELECT 'abc'");
      $res->fetch_assoc();
      $res->close();

  Chaque opération de récupération augmentera la valeur.

  Cependant, la statistique ne sera pas augmentée si l'ensemble de résultats est uniquement mis en mémoire tampon sur le client, mais non extrait, comme dans l'exemple suivant :

      $mysqli = new mysqli();
      $res = $mysqli->query("SELECT 'abc'");
      $res->close();

`bytes_received_real_data_ps`
  Le nombre d'octets de charge utile récupérés par le client PHP depuis `mysqlnd` en utilisant le protocole de déclaration préparée. Ceci est la taille des données réelles contenues dans les ensembles de résultats qui proviennent de déclarations préparées et qui ont été récupérées par le client PHP. La valeur ne sera pas augmentée si l'ensemble de résultats n'est pas lu par le client PHP. Il est à noter que bien qu'un ensemble de résultats complet ait pu être extrait de MySQL par `mysqlnd`, cette statistique ne compte que les données réelles extraites de `mysqlnd` par le client PHP. Voir également `bytes_received_real_data_normal`.

Statistiques liées aux ensembles de résultats
`result_set_queries`
  Le nombre de requêtes qui ont généré un ensemble de résultats. Exemple de requêtes qui génèrent un ensemble de résultats : `SELECT`, `SHOW`. La statistique ne sera pas augmentée s'il y a une erreur lors de la lecture de l'en-tête du paquet de l'ensemble de résultats.

  > Note: Cette statistique peut être utilisée comme mesure indirecte du nombre de requêtes que PHP a envoyées à MySQL. Cela peut aider à identifier un client qui provoque une charge élevée sur la base de données.

`non_result_set_queries`
  Le nombre de requêtes qui n'ont pas généré d'ensemble de résultats. Exemples de requêtes qui ne génèrent pas d'ensemble de résultats : `INSERT`, `UPDATE`, `LOAD DATA`. Cette statistique ne sera pas augmentée s'il y a une erreur lors de la lecture de l'en-tête du paquet de l'ensemble de résultats.

  > Note: Cette statistique peut être utilisée comme mesure indirecte du nombre de requêtes que PHP a envoyées à MySQL. Cela peut aider à identifier un client qui provoque une charge élevée sur la base de données.

`no_index_used`
  Le nombre de requêtes qui ont généré un ensemble de résultats mais n'ont pas utilisé d'index. (Voir également l'option de démarrage de mysqld `--log-queries-not-using-indexes`).

  > Note: Ces requêtes peuvent être signalées via une exception en appelant `mysqli_report(MYSQLI_REPORT_INDEX);`. Il est possible de les signaler via un avertissement en appelant `mysqli_report(MYSQLI_REPORT_INDEX ^ MYSQLI_REPORT_STRICT);`.

`bad_index_used`
  Le nombre de requêtes qui ont généré un ensemble de résultats et n'ont pas utilisé un bon index. (Voir également l'option de démarrage de mysqld `--log-slow-queries`).

  > Note: Ces requêtes peuvent être signalées via une exception en appelant `mysqli_report(MYSQLI_REPORT_INDEX);`. Il est possible de les signaler via un avertissement en appelant `mysqli_report(MYSQLI_REPORT_INDEX ^ MYSQLI_REPORT_STRICT);`.

`slow_queries`
  Les déclarations SQL qui ont pris plus de `long_query_time` secondes à s'exécuter et ont nécessité au moins `min_examined_row_limit` lignes à examiner.
  Attention

  Pas signalé via mysqli_report().

`buffered_sets`
  Le nombre d'ensembles de résultats mis en mémoire tampon retournés par des requêtes normales (c'est-à-dire pas via une déclaration préparée).

  Exemple d'appels API qui mettront en mémoire tampon les ensembles de résultats sur le client : mysqli_query(), mysqli_store_result(), mysqli_stmt_get_result()

`unbuffered_sets`
  Le nombre d'ensembles de résultats non mis en mémoire tampon retournés par des requêtes normales (c'est-à-dire pas via une déclaration préparée).

  Exemple d'appels API qui ne mettront pas en mémoire tampon les ensembles de résultats sur le client : mysqli_use_result()

`ps_buffered_sets`
  Le nombre d'ensembles de résultats mis en mémoire tampon retournés par des déclarations préparées.

  Exemple d'appels API qui mettront en mémoire tampon les ensembles de résultats sur le client : mysqli_stmt_store_result()

`ps_unbuffered_sets`
  Le nombre d'ensembles de résultats non mis en mémoire tampon retournés par des déclarations préparées. Par défaut les déclarations préparées ne sont pas mises en mémoire tampon, ainsi la plupart des déclarations préparées seront comptabilisées dans cette statistique.
`flushed_normal_sets`
  Le nombre de jeux de résultats retournés par des requêtes normales (c'est-à-dire pas via une déclaration préparée) avec des données non lues qui ont été silencieusement vidées.

  > Note: Le vidage se produit uniquement avec des ensembles de résultats non mis en mémoire tampon. Les ensembles de résultats non mis en mémoire tampon doivent être récupérés complètement avant qu'une nouvelle requête puisse être exécutée sur la connexion, sinon MySQL lancera une erreur. Si l'application ne récupère pas toutes les lignes d'un ensemble de résultats non mis en mémoire tampon, mysqlnd récupère implicitement l'ensemble de résultats pour effacer la ligne. Voir également `rows_skipped_normal`, `rows_skipped_ps`.

  > Quelques causes possibles pour un vidage implicite :

  > - Application cliente défectueuse
  > - Client s'est arrêté de lire après avoir trouvé ce qu'il cherchait mais a fait calculer à MySQL plus de lignes que nécessaire
  > - L'application client s'est arrêtée de manière inattendue

`flushed_ps_sets`
  Le nombre de jeux de résultats retournés par des déclarations préparées avec des données non lues qui ont été silencieusement vidées.

  > Note: Le vidage se produit uniquement avec des ensembles de résultats non mis en mémoire tampon. Les ensembles de résultats non mis en mémoire tampon doivent être récupérés complètement avant qu'une nouvelle requête puisse être exécutée sur la connexion, sinon MySQL lancera une erreur. Si l'application ne récupère pas toutes les lignes d'un ensemble de résultats non mis en mémoire tampon, mysqlnd récupère implicitement l'ensemble de résultats pour effacer la ligne. Voir également `rows_skipped_normal`, `rows_skipped_ps`.

  > Quelques causes possibles pour un vidage implicite :

  > - Application cliente défectueuse
  > - Client s'est arrêté de lire après avoir trouvé ce qu'il cherchait mais a fait calculer à MySQL plus de lignes que nécessaire
  > - L'application client s'est arrêtée de manière inattendue

`ps_prepared_never_executed`
  Le nombre de déclarations préparées préparées mais jamais exécutées.
`ps_prepared_once_executed`
  Le nombre de déclarations préparées exécutées une seule fois.
`rows_fetched_from_server_normal`
`rows_fetched_from_server_ps`
  Le nombre total de lignes d'ensemble de résultats récupérées du serveur. Cela inclut les lignes qui n'ont pas été lues par le client mais ont été implicitement récupérées en raison d'ensembles de résultats non mis en mémoire tampon vidés. Voir également `packets_received_rset_row`.
`rows_buffered_from_client_normal`
  Le nombre total de lignes mises en mémoire tampon provenant d'une requête normale. Ceci est le nombre de lignes qui ont été récupérées de MySQL et mises en mémoire tampon sur le client.

  Exemple de requêtes qui mettront en mémoire tampon les ensembles de résultats :

  - mysqli_query()
  - mysqli_store_result()
`rows_buffered_from_client_ps`
  Equivalent à `rows_buffered_from_client_normal` mais pour les déclarations préparées.
`rows_fetched_from_client_normal_buffered`
  Le nombre total de lignes récupérées par le client à partir d'un ensemble de résultats mis en mémoire tampon créé par une requête normale.
`rows_fetched_from_client_ps_buffered`
  Le nombre total de lignes récupérées par le client à partir d'un ensemble de résultats mis en mémoire tampon créé par une déclaration préparée.
`rows_fetched_from_client_normal_unbuffered`
  Le nombre total de lignes récupérées par le client à partir d'un ensemble de résultats non mis en mémoire tampon créé par une requête normale.
`rows_fetched_from_client_ps_unbuffered`
  Le nombre total de lignes récupérées par le client à partir d'un ensemble de résultats non mis en mémoire tampon créé par une déclaration préparée.
`rows_fetched_from_client_ps_cursor`
  Le nombre total de lignes récupérées par le client à partir d'un curseur créé par une déclaration préparée.
`rows_skipped_normal`
`rows_skipped_ps`
  Réservé pour une utilisation future (actuellement non pris en charge).
`copy_on_write_saved`
`copy_on_write_performed`
  Ceci est une statistique de portée de processus. Avec mysqlnd, les variables retournées par les extensions pointent vers mysqlnd tampons de résultats internes. Si les données ne sont pas modifiées, les données extraites ne sont conservées qu'une seule fois en mémoire. Cependant, toute modification des données nécessitera à mysqlnd de réaliser une opération de copie-sur-écriture.
`explicit_free_result`
`implicit_free_result`
  Ceci est une statistique de portée de connexion et de processus. Le nombre total de résultats libérés.
`proto_text_fetched_null`
  Le nombre total de colonnes de type `MYSQL_TYPE_NULL` récupérées à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_null`
  Le nombre total de colonnes de type `MYSQL_TYPE_NULL` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_bit`
  Le nombre total de colonnes de type `MYSQL_TYPE_BIT` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_bit`
  Le nombre total de colonnes de type `MYSQL_TYPE_BIT` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_tinyint`
  Le nombre total de colonnes de type `MYSQL_TYPE_TINY` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_tinyint`
  Le nombre total de colonnes de type `MYSQL_TYPE_TINY` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_short`
  Le nombre total de colonnes de type `MYSQL_TYPE_SHORT` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_short`
  Le nombre total de colonnes de type `MYSQL_TYPE_SHORT` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_int24`
  Le nombre total de colonnes de type `MYSQL_TYPE_INT24` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_int24`
  Le nombre total de colonnes de type `MYSQL_TYPE_INT24` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_int`
  Le nombre total de colonnes de type `MYSQL_TYPE_LONG` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_int`
  Le nombre total de colonnes de type `MYSQL_TYPE_LONG` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_bigint`
  Le nombre total de colonnes de type `MYSQL_TYPE_LONGLONG` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_bigint`
  Le nombre total de colonnes de type `MYSQL_TYPE_LONGLONG` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_decimal`
  Le nombre total de colonnes de type `MYSQL_TYPE_DECIMAL`, ou `MYSQL_TYPE_NEWDECIMAL` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_decimal`
  Le nombre total de colonnes de type `MYSQL_TYPE_DECIMAL`, ou `MYSQL_TYPE_NEWDECIMAL` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_float`
  Le nombre total de colonnes de type `MYSQL_TYPE_FLOAT` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_float`
  Le nombre total de colonnes de type `MYSQL_TYPE_FLOAT` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_double`
  Le nombre total de colonnes de type `MYSQL_TYPE_DOUBLE` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_double`
  Le nombre total de colonnes de type `MYSQL_TYPE_DOUBLE` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_date`
  Le nombre total de colonnes de type `MYSQL_TYPE_DATE`, ou `MYSQL_TYPE_NEWDATE` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_date`
  Le nombre total de colonnes de type `MYSQL_TYPE_DATE`, ou `MYSQL_TYPE_NEWDATE` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_year`
  Le nombre total de colonnes de type `MYSQL_TYPE_YEAR` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_year`
  Le nombre total de colonnes de type `MYSQL_TYPE_YEAR` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_time`
  Le nombre total de colonnes de type `MYSQL_TYPE_TIME` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_time`
  Le nombre total de colonnes de type `MYSQL_TYPE_TIME` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_datetime`
  Le nombre total de colonnes de type `MYSQL_TYPE_DATETIME` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_datetime`
  Le nombre total de colonnes de type `MYSQL_TYPE_DATETIME` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_timestamp`
  Le nombre total de colonnes de type `MYSQL_TYPE_TIMESTAMP` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_timestamp`
  Le nombre total de colonnes de type `MYSQL_TYPE_TIMESTAMP` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_string`
  Le nombre total de colonnes de type `MYSQL_TYPE_STRING`, `MYSQL_TYPE_VARSTRING`, ou `MYSQL_TYPE_VARCHAR` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_string`
  Le nombre total de colonnes de type `MYSQL_TYPE_STRING`, `MYSQL_TYPE_VARSTRING`, ou `MYSQL_TYPE_VARCHAR` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_blob`
  Le nombre total de colonnes de type `MYSQL_TYPE_TINY_BLOB`, `MYSQL_TYPE_MEDIUM_BLOB`, ou `MYSQL_TYPE_BLOB` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_blob`
  Le nombre total de colonnes de type `MYSQL_TYPE_TINY_BLOB`, `MYSQL_TYPE_MEDIUM_BLOB`, `MYSQL_TYPE_LONG_BLOB`, ou `MYSQL_TYPE_BLOB` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_enum`
  Le nombre total de colonnes de type `MYSQL_TYPE_ENUM` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_enum`
  Le nombre total de colonnes de type `MYSQL_TYPE_ENUM` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_set`
  Le nombre total de colonnes de type `MYSQL_TYPE_SET` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_set`
  Le nombre total de colonnes de type `MYSQL_TYPE_SET` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_geometry`
  Le nombre total de colonnes de type `MYSQL_TYPE_GEOMETRY` récupéré à partir d'une requête normale (protocole texte MySQL).
`proto_binary_fetched_geometry`
  Le nombre total de colonnes de type `MYSQL_TYPE_GEOMETRY` récupéré à partir d'une déclaration préparée (protocole binaire MySQL).
`proto_text_fetched_other`
  Le nombre total de colonnes de types `MYSQL_TYPE_*` non listés précédemment récupéré à partir d'une requête normale (protocole texte MySQL).

  > Note: Dans la théorie, cela devrait toujours être `0`.

`proto_binary_fetched_other`
  Le nombre total de colonnes de type `MYSQL_TYPE_*` non listés précédemment récupéré à partir d'une déclaration préparée (protocole binaire MySQL).

  > Note: Dans la théorie, cela devrait toujours être `0`.

Statistiques liées aux connexions
`connect_success`
  Le nombre total de tentatives de connexion réussies.

  > Note: `connect_success` contient la somme des tentatives de connexion réussies persistantes et non persistantes. Par conséquent, le nombre de tentatives de connexion non persistantes réussies est `connect_success - pconnect_success`.

`pconnect_success`
  Le nombre total de tentatives de connexion persistantes réussies.
`connect_failure`
  Le nombre total de tentatives de connexion échouées.
`reconnect`
  Ceci est une statistique de portée de processus.
`active_connections`
  Ceci est une statistique de portée de processus. Le nombre total de connexions persistantes et non persistantes actives.

  > Note: Le nombre total de connexions non persistantes actives est `active_connections - active_persistent_connections`.

`active_persistent_connections`
  Ceci est une statistique de portée de processus. Le nombre total de connexions persistantes actives.
`explicit_close`
  Le nombre total de connexions explicitement fermées.

  Exemple #1 Exemples de fragments de code qui provoquent une fermeture explicite

  -     $link = new mysqli(/* ... */);
        $link->close(/* ... */);

  -     $link = new mysqli(/* ... */);
        $link->connect(/* ... */);

`implicit_close`
  Le nombre total de connexions implicitement fermées.

  Exemple #2 Exemples de fragments de code qui provoquent une fermeture implicite

  -     $link = new mysqli(/* ... */);
        $link->real_connect(/* ... */);

  - `unset($link)`
  - Connexion persistante: une connexion groupée a été créée avec real_connect et il peut y avoir des options inconnues définies - fermer implicitement pour éviter de retourner une connexion avec des options inconnues
  - Connexion persistante: ping/change_user échoue et ext/mysqli ferme la connexion
  - Fin de l'exécution du script : fermeture des connexions qui n'ont pas été fermées par l'utilisateur
`disconnect_close`
  Échecs de connexion indiqués par l'appel à l'API C `mysql_real_connect` lors d'une tentative d'établissement de connexion.
`in_middle_of_command_close`
  Ceci est une statistique de portée de processus. Une connexion a été fermée au milieu de l'exécution d'une commande (ensembles de résultats non récupérés, après l'envoi d'une requête et avant de récupérer une réponse, pendant la récupération de données, pendant le transfert de données avec LOAD DATA).
  Avertissement

  Sauf si des requêtes asynchrones sont utilisées, cela ne devrait se produire que si l'application PHP s'est terminée de manière inattendue et que PHP ferme automatiquement la connexion.

`init_command_executed_count`
  Le nombre total d'exécutions de commandes d'initialisation. Par exemple: `mysqli_options(MYSQLI_INIT_COMMAND , $value)`. Le nombre d'exécutions réussies est `init_command_executed_count - init_command_failed_count`.
`init_command_failed_count`
  Le nombre total d'échecs d'exécution de commandes d'initialisation.

`COM_*` Statistiques liées aux commandes
`com_quit`
`com_init_db`
`com_query`
`com_field_list`
`com_create_db`
`com_drop_db`
`com_refresh`
`com_shutdown`
`com_statistics`
`com_process_info`
`com_connect`
`com_process_kill`
`com_debug`
`com_ping`
`com_time`
`com_delayed_insert`
`com_change_user`
`com_binlog_dump`
`com_table_dump`
`com_connect_out`
`com_register_slave`
`com_stmt_prepare`
`com_stmt_execute`
`com_stmt_send_long_data`
`com_stmt_close`
`com_stmt_reset`
`com_stmt_set_option`
`com_stmt_fetch`
`com_daemon`
  Le nombre total de tentatives d'envoi d'une certaine commande `COM_*` de PHP à MySQL. La statistique est incrémentée après avoir vérifié la ligne et immédiatement avant d'envoyer le paquet de protocole client serveur MySQL correspondant.
  Attention

  Si MySQLnd échoue à envoyer le paquet sur le réseau, les statistiques ne seront pas décrémentées. En cas d'échec, MySQLnd émet un avertissement PHP Error while sending %s packet. PID=%d.

  Exemple #3 Exemples d'utilisation

  - Vérifier si PHP envoie certaines commandes à MySQL, par exemple, vérifier si un client envoie `COM_PROCESS_KILL`
  - Calculer le nombre moyen d'exécutions de commandes préparées en comparant `COM_EXECUTE` avec `COM_PREPARE`
  - Vérifier si PHP a exécuté des déclarations SQL non préparées en vérifiant si `COM_QUERY` est zéro
  - Identifier les scripts PHP qui exécutent un nombre excessif de déclarations SQL en vérifiant `COM_QUERY` et `COM_EXECUTE`

Statistiques diverses
`explicit_stmt_close`
`implicit_stmt_close`
  Ceci est une statistique de portée de processus. Le nombre total de déclarations préparées explicitement fermées.

  > Note: Une déclaration préparée est toujours explicitement fermée. La seule fois où elle est fermée implicitement est lorsque sa préparation échoue.

`mem_emalloc_count`
`mem_emalloc_ammount`
`mem_ecalloc_count`
`mem_ecalloc_ammount`
`mem_realloc_count`
`mem_realloc_ammount`
`mem_efree_count`
`mem_malloc_count`
`mem_malloc_ammount`
`mem_calloc_count`
`mem_calloc_ammount`
`mem_ealloc_count`
`mem_ealloc_ammount`
`mem_free_count`
  Ceci est une statistique de portée de processus. Appelle la gestion de la mémoire.
`command_buffer_too_small`
  Le nombre d'extensions de tampon de commande réseau lors de l'envoi de commandes de PHP à MySQL. MySQLnd alloue un tampon de commande/réseau interne de mysqlnd.net_cmd_buffer_size octets pour chaque connexion. Si un protocole de commande de serveur MySQL, par exemple `COM_QUERY` (requête normale), ne rentre pas dans le tampon, mysqlnd étendra le tampon à ce qui est nécessaire pour envoyer la commande. Chaque fois que le tampon est étendu pour une connexion `command_buffer_too_small` sera incrémenté d'un. Si mysql est obligé de faire croître le tampon au-delà de sa taille initiale de mysqlnd.net_cmd_buffer_size octets pour presque chaque connexion, des considérations pour augmenter la taille par défaut devraient être prises en compte pour éviter les réallocations.
`connection_reused`
  Le nombre total de fois qu'une connexion persistante a été réutilisée.

`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open