# Statistiques

Utilisation des donnés statistiques

Le pilote natif MySQL peut collecter des statistiques sur la communication entre le client et le serveur. Ces statistiques sont de deux sortes :

- Les statistiques client

- Les statistiques de connexion

Si vous utilisez l'extension mysqli, ces statistiques sont disponibles via deux appels d'API :

- mysqli_get_client_stats()

- mysqli_get_connection_stats()

> Note:

> Les statistiques sont agrégées entre toutes les extensions qui utilisent le pilote natif MySQL. Par exemple, quand les extensions ext/mysql et ext/mysqli sont toutes deux compilées par rapport au pilote natif MySQL, les appels de fonctions de ext/mysql et ext/mysqli changeront tous les deux les statistiques. Il n'y a aucun moyen de savoir comment des appels à une certaine API compilée par rapport au pilote natif MySQL ont modifié une statistique donnée. Vous pouvez configurer le pilote PDO MySQL, ext/mysql et ext/mysqli pour éventuellement utiliser le pilote natif MySQL. Dans ce cas, les trois extensions modifieront les statistiques.

Accéder aux statistiques client

Pour accéder aux statistiques client, vous devez appeler mysqli_get_client_stats(). L'appel à la fonction ne requiert aucun paramètre.

Cette fonction retourne un tableau associatif contenant le nom de la statistique comme clé et la donnée statistiques comme valeur.

Les statistiques client peuvent aussi être accédées via la fonction phpinfo().

Accéder aux statistiques de connexion

Pour accéder aux statistiques client, vous devez appeler mysqli_get_connection_stats(). Cette fonction prend en paramètre la ressource de connexion à la base de données.

Cette fonction retourne un tableau associatif contenant le nom de la statistique comme clé et la donnée statistique comme valeur.

Buffered and Unbuffered Result Sets

Les jeux de résultats peuvent être mis ou non en tampon. Le paramétrage par défaut fait fonctionner ext/mysql et ext/mysqli avec des jeux de résultats en tampon pour des requêtes normales (non préparées). Les jeux de résultats sont stockés côté client. Après l'exécution de la requête, tous les résultats sont récupérés du serveur MySQL et mis en cache côté client. Le grand avantage de jeux de résultat mis en tampon est qu'ils autorisent le serveur à libérer les ressources allouées à un jeu de résultat, dès que ceux-ci ont été récupérés par le client.

D'autre part, des jeux de résultats non mis en tampon sont gardés plus longtemps sur le serveur. Si vous voulez réduire la consommation de mémoire côté client, mais en contre-partie augmenter la charge sur le serveur, ne mettez pas les résultats en tampon. Si vous avez par contre une charge serveur importante et que vos soupçons se portent sur les résultats non mis en tampon, vous devriez considérer de déplacer la charge côté client. Les clients s'adaptent généralement plus facilement que les serveurs. La charge (Load) ne concerne pas seulement les tampons mémoire. En effet, le serveur a aussi besoin de garder d'autres ressources ouvertes, par exemple des threads ou des descripteurs de fichier, avant qu'un jeu de résultat ne soit libéré.

Les requêtes préparées ne mettent pas par défaut les résultats en tampon. Vous pouvez toujours utiliser mysqli_stmt_store_result() pour activer la mise en tampon des résultats.

Statistiques retournées par le pilote natif MySQL

Le tableau suivant présente une liste des statistiques retournées par les fonctions mysqli_get_client_stats() et mysqli_get_connection_stats().

Statistiques retournées par mysqlnd : Réseau
Statistique | Contexte | Description | Notes
--- | --- | --- | ---
bytes_sent | Connexion | Nombre d'octets envoyés de PHP vers le serveur MySQL | Peut être utilisé pour vérifier l'efficacité du protocole compressé
bytes_received | Connexion | Nombres d'octets reçus du serveur MySQL | Peut être utilisé pour vérifier l'efficacité du protocole compressé
packets_sent | Connexion | Nombre de paquets envoyés de type client-serveur MySQL | Utilisé pour déboguer l'implémentation du protocole client-serveur
packets_received | Connexion | Nombre de paquets reçus de type client-serveur MySQL | Utilisé pour déboguer l'implémentation du protocole client-serveur
protocol_overhead_in | Connexion | Le surcoût en octets du protocole client-serveur MySQL pour le trafic entrant. Actuellement, seul l'en-tête de paquet (4 octets) est considéré comme du surcoût. protocol_overhead_in = packets_received * 4 | Utilisé pour déboguer l'implémentation du protocole client-serveur
protocol_overhead_out | Connexion | Le surcoût en octets du protocole client-serveur MySQL pour le trafic sortant. Actuellement, seul l'en-tête de paquet (4 octets) est considéré comme du surcoût. protocol_overhead_in = packets_received * 4 | Utilisé pour déboguer l'implémentation du protocole client-serveur
bytes_received_ok_packet | Connexion | Nombre total d'octets des paquets du protocole client-serveur MySQL reçus avec un statut OK. Les paquets reçus avec un statut OK peuvent contenir un message de statut. La longueur de ce message de statut peut varier, entrainant de ce fait une taille non-fixe de paquet OK. | Utilisé pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
packets_received_ok | Connexion | Nombre total de paquets du protocole client-serveur MySQL reçus avec un statut OK. | Utilisé pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
bytes_received_eof_packet | Connexion | Taille totale en octets des paquets EOF reçus avec le protocole client-serveur MySQL. La taille de EOF peut varier selon la version du serveur. De plus, EOF peut contenir un message d'erreur. | Utilisé pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
packets_received_eof | Connexion | Nombre total de paquets EOF reçus avec le protocole client-serveur MySQL. Comme avec d'autres statistiques sur les paquets, le nombre de paquets augmentera même si PHP ne reçoit pas le paquet attendu, mais par exemple un message d'erreur. | Utilisé pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
bytes_received_rset_header_packet | Connexion | Taille totale en octets des paquets d'en-tête de jeux de résultats reçus avec le protocole client-serveur MySQL. La taille des paquets varie selon le type de données transportées (LOAD LOCAL INFILE, INSERT, UPDATE, SELECT, messages d'erreur). | Utilisé pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
packets_received_rset_header | Connexion | Nombre de paquets d'en-tête de jeux de résultats reçus avec le protocole client-serveur MySQL. | Utilisé pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
bytes_received_rset_field_meta_packet | Connexion | Taille totale en octets des paquets de méta-données (informations sur les champs) de jeux de résultats reçus avec le protocole client-serveur MySQL. Bien entendu, la taille varie selon les champs contenus dans le jeu de résultats. Le paquet peut aussi transporter une erreur ou un EOF dans le cas de COM_LIST_FIELDS. | Utile seulement pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
packets_received_rset_field_meta | Connexion | Nombre de paquets de méta-données (informations sur les champs) de jeux de résultats reçus avec le protocole client-serveur MySQL. | Utile seulement pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
bytes_received_rset_row_packet | Connexion | Taille totale en octets des paquets de données pures de jeux de résultats reçus avec le protocole client-serveur MySQL. Le paquet peut aussi transporter une erreur ou un paquet EOF. Vous pouvez faire du rétro-engeneering sur le nombre de paquets d'erreurs ou de paquets EOF en soustrayant rows_fetched_from_server_normal et rows_fetched_from_server_ps de bytes_received_rset_row_packet. | Utile seulement pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
packets_received_rset_row | Connexion | Nombre de paquets de données pures de jeux de résultats reçus avec le protocole client-serveur MySQL et leur taille totale en octets. | Utile seulement pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
bytes_received_prepare_response_packet | Connexion | Taille totale en octets des paquets "OK for Prepared Statement Initialization packets (paquets d'initialisation des commandes préparées). Le paquet peut aussi traporter une erreur. La taille du paquet dépend de la version de MySQL : 9 octets avec MySQL 4.1 et 12 octets à partir de MySQL 5.0. Il n'y a aucun moyen sûr de savoir combien d'erreurs sont survenues. Vous pouvez éventuellement deviner qu'une erreur est survenue si, par exemple, vous vous connectez toujours à MySQL 5.0 ou supérieur et que bytes_received_prepare_response_packet != packets_received_prepare_response * 12. Regardez aussi ps_prepared_never_executed et ps_prepared_once_executed. | Utile seulement pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
packets_received_prepare_response | Connexion | Nombre de paquets "OK for Prepared Statement Initialization packets (paquets d'initialisation des commandes préparées). | Utile seulement pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
bytes_received_change_user_packet | Connexion | Taille totale en octets des paquets COM_CHANGE_USER reçus avec le protocole client-serveur MySQL. Le paquet peut aussi transporter une erreur ou un EOF. | Utile seulement pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
packets_received_change_user | Connexion | Nombre de paquets COM_CHANGE_USER reçus avec le protocole client-serveur MySQL. | Utile seulement pour déboguer l'implémentation du protocole client-serveur. Notez bien que la taille totale en octets inclut la taille du paquet d'en-tête (4 octets, comme indiqué dans le surcoût du protocole).
packets_sent_command | Connexion | Nombre de paquets envoyés de PHP vers MySQL avec le protocole client-serveur MySQL. Il n'y a aucun moyen de savoir quelle commande spécifique a été envoyée et en quel quantité. Au mieux, vous pouvez vous en servir pour savoir si PHP a envoyé des commandes à MySQL et ainsi savoir si vous pouvez supprimer le support de MySQL dans votre binaire PHP. Il n'y a de même aucun moyen de faire du rétro-engeneering sur le nombre d'erreurs qui ont pu survenir lors de l'envoi de données à MySQL. La seule erreur recodée est command_buffer_too_small (voir ci-après). | Utile seulement pour déboguer l'implémentation du protocole client-serveur.
bytes_received_real_data_normal | Connexion | Nombre d'octets de charge récupérés par le client PHP depuis mysqlnd en utilisant le protocole de texte. | C'est la taille des données actuellement contenues dans les jeux de résultats qui ne proviennent pas des commandes préparées et qui ont été récupérées par le client PHP. Notez que même si un jeu de résultat complet a pu être récupéré de MySQL par mysqlnd, cette statistique ne compte que les données actuellement récupérées depuis mysqlnd par le client PHP. Un exemple de code qui incrémentra cette valeur:
    $mysqli = new mysqli();
    $res = $mysqli->query("SELECT 'abc'");
    $res->fetch_assoc();
    $res->close();
Chaque opération de récupération (fetch) incrémentera cette valeur. Cette statistique ne sera pas incrémentée si le jeu de résultats est mis en tampon seulement sur le client, mais pas récupéré. Par exemple:
    $mysqli = new mysqli();
    $res = $mysqli->query("SELECT 'abc'");
    $res->close();
Cette statistique est disponible depuis PHP 5.3.4.
bytes_received_real_data_ps | Connexion | Nombre d'octets de charge récupérés par le client PHP depuis mysqlnd en utilisant le protocole de commande préparée. | C'est la taille des données actuellement contenues dans un jeu de résultats provenant d'une commande préparée et qui a été récupérée par le client PHP. La valeur ne sera pas incrémentée si le jeu de résultat n'est pas lu par le client PHP. Notez que même si un jeu de résultats complet a pu être récupéré depuis MySQL par mysqlnd, cette statistique ne compte que les données récupérées par le client PHP depuis mysqlnd. Voyez aussi bytes_received_real_data_normal. Cette statistique est disponible depuis PHP 5.3.4.

Jeu de résultats

Statistiques retournées par mysqlnd : Jeu de résultats
Statistique | Contexte | Description | Notes
--- | --- | --- | ---
result_set_queries | Connexion | Nombre de requêtes qui ont généré un jeu de résultats. Des exemples de requêtes qui génèrent un jeu de résultats : SELECT et SHOW. Cette statistique ne sera pas incrémentée si une erreur survient lors de la lecture du paquet d'en-tête du jeu de résultats. | Vous pouvez l'utiliser comme mesure indirecte du nombre de requêtes que PHP a envoyées à MySQL pour identifier, par exemple, un client qui provoque beaucoup de charge sur la base de données.
non_result_set_queries | Connexion | Nombre de requêtes qui n'ont pas généré de jeu de résultats. Des exemples de requêtes qui ne génèrent pas de jeu de résultats : INSERT, UPDATE, LOAD DATA. Cette statistique ne sera pas incrémentée si une erreur survient lors de la lecture du paquet d'en-tête du jeu de résultats. | Vous pouvez l'utiliser comme mesure indirecte du nombre de requêtes que PHP a envoyées à MySQL pour identifier, par exemple, un client qui provoque beaucoup de charge sur la base de données.
no_index_used | Connexion | Nombre de requêtes qui ont généré un jeu de résultats mais qui n'ont pas utilisé d'index (voir aussi l'option de démarrage de mysqld : –log-queries-not-using-indexes). Si vous voulez que ces requêtes soient rapportées, vous pouvez utiliser mysqli_report(MYSQLI_REPORT_INDEX) pour que ext/mysqli jette une exception. Si vous préférez un avertissement plutôt qu'une exception, utilisez mysqli_report(MYSQLI_REPORT_INDEX ^ MYSQLI_REPORT_STRICT). |
bad_index_used | Connexion | Nombre de requêtes qui ont généré un jeu de résultats mais qui n'ont pas utilisé un bon index (voir aussi l'option de démarrage de mysqld : –log-slow-queries). | Si vous voulez que ces requêtes soient rapportées, vous pouvez utiliser mysqli_report(MYSQLI_REPORT_INDEX) pour que ext/mysqli jette une exception. Si vous préférez un avertissement plutôt qu'une exception, utilisez mysqli_report(MYSQLI_REPORT_INDEX ^ MYSQLI_REPORT_STRICT).
slow_queries | Connexion | Les commandes SQL qui ont pris plus de long_query_time secondes à être exécutées et qui ont nécessité qu'au moins min_examined_row_limit enregistrements soient examinés. | Non reporté par mysqli_report()
buffered_sets | Connexion | Nombre de jeux de résultats retournés par des requêtes normales et qui ont été mis en tampon. normale signifie commande non préparée dans les notes qui suivent. | Des exemples d'appel à l'API, qui ne mettront pas les jeux de résultats en tampon côté client : mysql_query(), mysqli_query(), mysqli_store_result(), mysqli_stmt_get_result(). Mettre les jeux de résultat en tampon côté client assure que les ressources allouées côté serveur sont libérées dès que possible et rend la navigation dans le jeu de résultat plus aisée. L'inconvénient, c'est une consommation mémoire plus importante côté client pour mettre les jeux de résultats en tampon. Notez que mysqlnd (contrairement à la bibliothèque cliente MySQL) respecte la limite de mémoire de PHP pour l'allocation, car mysqlnd utilise les fonctions de gestion de mémoire internes de PHP. C'est aussi pourquoi memory_get_usage() rapporte une consommation mémoire plus importante quand on utilise mysqlnd plutôt que la bibliothèque cliente MySQL. memory_get_usage() ne mesure pas la consommation mémoire de la bibliothèque cliente MySQL car celle-ci n'utilise pas les fonctions de gestion de mémoire internes de PHP, mésurées par cette fonction!
unbuffered_sets | Connexion | Nombre de jeux de résultats non mis en tampon retournés par des requêtes normales (pas de commande préparée). | Des exemples d'appels à l'API qui ne mettent pas les jeux de résultats en tampon côté client : mysqli_use_result()
ps_buffered_sets | Connexion | Nombre de jeux de résultats mis en tampon retournés par des commandes préparées. Par défaut, les commandes préparées ne sont pas mises en tampon. | Des exemples d'appels à l'API qui mettent les jeux de résultats en tampon côté client : mysqli_stmt_store_result
ps_unbuffered_sets | Connexion | Nombre de jeux de résultats non mis en tampon retournés par des commandes préparées. | Par défaut, les commandes préparées ne sont pas mises en tampon.
flushed_normal_sets | Connexion | Nombre de jeux de résultats issus de requêtes normales (pas de commande préparée) avec des données non lues qui ont été évacuées implicitement. L'évacuation n'a lieu qu'avec les jeux de résultats non mis en tampon. | Les jeux de résultats non mis en tampon doivent être récupérés en totalité avant qu'une nouvelle requête puisse être passée sur la connexion, sans quoi MySQL renverra une erreur. Si l'application ne récupère pas tous les enregistrements d'un jeu de résultats non mis en tampon, mysqlnd récupère implicitement tout le jeu afin de laisser place nette. Voir aussi rows_skipped_normal et rows_skipped_ps. Quelques causes possibles d'une évacuation implicite : Une application cliente défectueuse Le client a arrêté de lire après qu'il a trouvé ce qu'il cherchait met a fait considérer à MySQL davantage d'enregistrements que nécessaire L'application cliente s'est arrêtée de façon inattendue
flushed_ps_sets | Connexion | Nombre de jeux de résultats issus de commandes préparées avec des données non lues qui ont été évacuées implicitement. L'évacuation n'a lieu qu'avec les jeux de résultats non mis en tampon. | Les jeux de résultats non mis en tampon doivent être récupérés en totalité avant qu'une nouvelle requête puisse être passée sur la connexion, sans quoi MySQL renverra une erreur. Si l'application ne récupère pas tous les enregistrements d'un jeu de résultats non mis en tampon, mysqlnd récupère implicitement tout le jeu afin de laisser place nette. Voir aussi rows_skipped_normal et rows_skipped_ps. Quelques causes possibles d'une évacuation implicite : Une application cliente défectueuse Le client a arrêté de lire après qu'il a trouvé ce qu'il cherchait met a fait considérer à MySQL davantage d'enregistrements que nécessaire L'application cliente s'est arrêtée de façon inattendue
ps_prepared_never_executed | Connexion | Nombre de commandes préparées mais jamais exécutées. | Les commandes préparées monopolisent des ressources serveur. Vous ne devriez pas préparer une commande si vous n'envisagez pas de l'exécuter.
ps_prepared_once_executed | Connexion | Nombre de commandes préparées exécutées une seule fois. | Un des principes des commandes préparées est que la même requête est exécutée encore et encore (avec des paramètres différents) de telle façon que des opérations d'analyse syntaxique et de préparation puissent être économisées si l'exécution de la commande est séparée en deux phases distinctes de préparation et d'exécution. L'idée est de préparer une fois et de mettre en cache les résultats pour que, par exemple, l'arbre d'analyse syntaxique puisse être réutilisé pour l'exécution de plusieurs commandes. Si vous exécutez une commande préparée uen seule fois, vous perdez tous le bénéfice des deux phases distinctes par rapport à des requêtes normales parce que la mise en cache représente du travail supplémentaire et monopolise des ressources (limitées) côté serveur. Par conséquent, les commandes préparées exécutées une seule fois peuvent provoquer des baisses de performance.
rows_fetched_from_server_normal, rows_fetched_from_server_ps | Connexion | Nombre total de jeux de résultats récupérés avec succès du serveur MySQL sans se soucier si l'application cliente les a utilisés ou pas. Certains des enregistrements peuvent ne pas avoir été récupérés par l'application cliente mais avoir été évacués de façon implicite. | Voir aussi packets_received_rset_row
rows_buffered_from_client_normal, rows_buffered_from_client_ps | Connexion | Nombre total d'enregistrements mis en tampon avec succès suite à une requête normale ou une commande préparée. C'est le nombre d'enregistrements qui ont été récupérés du serveur MySQL et mis en tampon par le client. Notez qu'il y a deux statistiques différentes : une sur les enregistrements ont été mis en tampon (de MySQL au tampon interne de mysqlnd) et l'autre sur les enregistrements mis en tampon qui ont été récupérés par l'application cliente (du tampon interne de mysqlnd vers l'application cliente). Si le nombre d'enregistrements mis en tampon est supérieur au nombre d'enregistrements récupérés, cela peut signifier que l'application cliente exécute des requêtes dont les enregistrements résultants sont plus grands que nécessaire, menant à des enregistrements non lus par le client. | Des exemples de requêtes qui mettent les résultats en tampon : mysqli_query(), mysqli_store_result()
rows_fetched_from_client_normal_buffered, rows_fetched_from_client_ps_buffered | Connexion | Nombre total d'enregistrements récupérés par le client à partir d'un jeu de résultat mis en tampon et créé à partir d'une requête normale ou d'une commande préparée. |
rows_fetched_from_client_normal_unbuffered, rows_fetched_from_client_ps_unbuffered | Connexion | Nombre total d'enregistrements récupérés par le client à partir d'un jeu de résultat non mis en tampon et créé à partir d'une requête normale ou d'une commande préparée. |
rows_fetched_from_client_ps_cursor | Connexion | Nombre total d'enregistrements récupérés par le client à partir d'un curseur créé par une commande préparée. |
rows_skipped_normal, rows_skipped_ps | Connexion | Reservé pour une utilisation future (actuellement non supporté) |
copy_on_write_saved, copy_on_write_performed | Processus | Avec mysqlnd, les variables retournées par l'extension pointent vers les tampons de résultats réseau internes à mysqlnd. Si vous en changez pas ces variables, les données récupérées seront gardées une seule fois en mémoire. Si vous changez les variables, mysqlnd doit faire une copie-avant-écriture (copy-on-write) pour protéger ces tampons de résultats réseau internes. Avec la bibliothèque cliente MySQL, vous gardez toujours les données récupérées en mémoire en deux exemplaires : un pour les tampons internes à la bibliothèque cliente MySQL et un pour les extensions. En théorie, mysqlnd peut vous faire économiser jusqu'à 40% de mémoire. Notez cependant que l'économie de mémoire ne peut pas être mésurée par memory_get_usage(). |
explicit_free_result, implicit_free_result | Connexion, Process (seulement pendant le ménage des commandes préparées) | Nombre total de jeux de résultats libérés. | La libération est toujours considérée comme explicite, sauf pour les jeux de résultats créés par des commandes d'initialisation, par exemple mysqli_options(MYSQLI_INIT_COMMAND , ...)
proto_text_fetched_null, proto_text_fetched_bit, proto_text_fetched_tinyint proto_text_fetched_short, proto_text_fetched_int24, proto_text_fetched_int proto_text_fetched_bigint, proto_text_fetched_decimal, proto_text_fetched_float proto_text_fetched_double, proto_text_fetched_date, proto_text_fetched_year proto_text_fetched_time, proto_text_fetched_datetime, proto_text_fetched_timestamp proto_text_fetched_string, proto_text_fetched_blob, proto_text_fetched_enum proto_text_fetched_set, proto_text_fetched_geometry, proto_text_fetched_other | Connexion | Nombre total de colonnes d'un certain type retournées à partir d'une requête normale (protocole texte MySQL). | Correspondance entre l'API C / les types de méta-données MySQL et le nom des statistiques : MYSQL_TYPE_NULL - proto_text_fetched_null MYSQL_TYPE_BIT - proto_text_fetched_bit MYSQL_TYPE_TINY - proto_text_fetched_tinyint MYSQL_TYPE_SHORT - proto_text_fetched_short MYSQL_TYPE_INT24 - proto_text_fetched_int24 MYSQL_TYPE_LONG - proto_text_fetched_int MYSQL_TYPE_LONGLONG - proto_text_fetched_bigint MYSQL_TYPE_DECIMAL, MYSQL_TYPE_NEWDECIMAL - proto_text_fetched_decimal MYSQL_TYPE_FLOAT - proto_text_fetched_float MYSQL_TYPE_DOUBLE - proto_text_fetched_double MYSQL_TYPE_DATE, MYSQL_TYPE_NEWDATE - proto_text_fetched_date MYSQL_TYPE_YEAR - proto_text_fetched_year MYSQL_TYPE_TIME - proto_text_fetched_time MYSQL_TYPE_DATETIME - proto_text_fetched_datetime MYSQL_TYPE_TIMESTAMP - proto_text_fetched_timestamp MYSQL_TYPE_STRING, MYSQL_TYPE_VARSTRING, MYSQL_TYPE_VARCHAR - proto_text_fetched_string MYSQL_TYPE_TINY_BLOB, MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_BLOB - proto_text_fetched_blob MYSQL_TYPE_ENUM - proto_text_fetched_enum MYSQL_TYPE_SET - proto_text_fetched_set MYSQL_TYPE_GEOMETRY - proto_text_fetched_geometry N'importe quel MYSQL_TYPE_* non encore listé (il ne doit y en avoir aucun) - proto_text_fetched_other A noter que les constantes de type MYSQL_* peuvent ne pas être associées avec le même type de colonne SQL dans toutes les versions de MySQL.
proto_binary_fetched_null, proto_binary_fetched_bit, proto_binary_fetched_tinyint proto_binary_fetched_short, proto_binary_fetched_int24, proto_binary_fetched_int, proto_binary_fetched_bigint, proto_binary_fetched_decimal, proto_binary_fetched_float, proto_binary_fetched_double, proto_binary_fetched_date, proto_binary_fetched_year, proto_binary_fetched_time, proto_binary_fetched_datetime, proto_binary_fetched_timestamp, proto_binary_fetched_string, proto_binary_fetched_blob, proto_binary_fetched_enum, proto_binary_fetched_set, proto_binary_fetched_geometry, proto_binary_fetched_other | Connexion | Nombre total de colonnes d'un certain type retournées à partir d'une commande préparée (protocole binaire MySQL). | Pour la correspondance des types, regardez proto_text_* décrit ci-dessus.

Statistiques retournées par mysqlnd : Connexion
Statistique | Contexte | Description | Notes
--- | --- | --- | ---
connect_success, connect_failure | Connexion | Nombre total de tentatives de connexions réussies / échouées. | Les connexions réutilisées et tous les autres types de connexions sont incluses.
reconnect | Processus | Nombre total de tentatives de (real_)connect faites sur un descripteur de connexion déjà ouvert. | Le code $link = new mysqli(...); $link->real_connect(...) provoquera une reconnexion. Ce qui n'est pas le cas de $link = new mysqli(...); $link->connect(...) car $link->connect(...) fermera explicitement la connexion existante avant qu'une nouvelle connexion soit établie.
pconnect_success | Connexion | Nombre total de tentatives de connexions persistantes réussies. | Notez que connect_success contient la somme des tentatives de connexions persistantes et non-persistantes réussies. Ainsi, le nombre de tentatives de connexions non-persistantes réussies est connect_success - pconnect_success.
active_connections | Connexion | Nombre total de connexions persistantes et non-persistantes actives. |
active_persistent_connections | Connexion | Nombre total de connexions persistantes actives. | Le nombre total de connexions non-persistantes actives est active_connections - active_persistent_connections.
explicit_close | Connexion | Nombre total de connexions fermées explicitement (seulement valable avec ext/mysqli). | Des exemples de code qui ferment explicitement une connexion :
    $link = new mysqli(...); $link->close(...)
    $link = new mysqli(...); $link->connect(...)
implicit_close | Connexion | Nombre total de connexions fermées implicitement (seulement valable avec ext/mysqli). | Des exemples de code qui ferment implicitement une connexion : $link = new mysqli(...); $link->real_connect(...) unset($link) Connexions persistantes : le groupe de connexions qui ont été créées avec real_connect et où il peut y avoir des jeu d'options inconnues - ferme implicitement la connexion pour éviter de retourner une connexion avec des options inconnues Connexions persistantes : ping/change_user échoue et ext/mysqli ferme la connexion Fin de l'exécution d'un script : ferme la connexion qui ne l'a pas été par l'utilisateur
disconnect_close | Connexion | Echecs de connexions indiqués par l'appel à l'API C mysql_real_connect() pendant la tentative de connexion. | Elle est appelée disconnect_close parce que le descripteur de connexion passé lors de l'appel à l'API C sera fermé.
in_middle_of_command_close | Processus | Une connexion a été fermée en plein milieu de l'exécution d'une commande (excluant les jeux de résultats non récupérés, après avoir envoyé une requête et avant d'avoir la réponse, en envoyant des données, en transférant des données avec LOAD DATA). | A moins que vous n'utilisiez les requêtes asynchrones, ceci ne devrait arriver que si votre script s'arrête de façon inopinée et que PHP ferme la connexion pour vous.
init_command_executed_count | Connexion | Nombre total d'exécution de commandes d'initialisation, par exemple, mysqli_options(MYSQLI_INIT_COMMAND , ...). | Le nombre de connexions avec succès est init_command_executed_count - init_command_failed_count.
init_command_failed_count | Connexion | Nombre total d'exécution échouées de commandes d'initialisation. |

Statistiques retournées par mysqlnd : Commande COM_*
Statistique | Contexte | Description | Notes
--- | --- | --- | ---
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 | Connexion | Nombre total de tentatives d'envoi d'une certaine commande COM_* command de PHP vers MySQL. | Les statistiques sont incrémentées après avoir vérifié la connexion et immédiatement avant d'envoyer le paquet correspondant du protocole client-serveur MySQL. Si mysqlnd échoue lors de l'envoi du paquet via la connexion, la statistique ne sera pas décrémentée. En cas d'échec, mysqlnd émet un avertissement PHP Error while sending %s packet. PID=%d. Exemples d'utilisation : Vérifie si PHP envoie certaines commandes à MySQL, vérifie par exemple si un client envoie COM_PROCESS_KILL Calcule le nombre moyen d'exécution de commandes préparées en comparant COM_EXECUTE et COM_PREPARE Vérifie si PHP a envoyé des commandes SQL non préparées en vérifiant si COM_QUERY vaut zéro Identifie si des scripts PHP utilisent un nombre excessif de requêtes SQL en vérifiant COM_QUERY et COM_EXECUTE

Divers

Statistiques retournées par mysqlnd : Divers
Statistique | Contexte | Description | Notes
--- | --- | --- | ---
explicit_stmt_close, implicit_stmt_close | Processus | Nombre total de fermetures de commandes préparées. | Une fermeture est toujours considérée comme explicite sauf dans le cas d'une préparation échouée.
mem_emalloc_count, mem_emalloc_ammount, mem_ecalloc_count, mem_ecalloc_ammount, mem_erealloc_count, mem_erealloc_ammount, mem_efree_count, mem_malloc_count, mem_malloc_ammount, mem_calloc_count, mem_calloc_ammount, mem_realloc_count, mem_realloc_ammount, mem_free_count | Processus | Appels à la gestion de la mémoire. | Seulement pour du développement.
command_buffer_too_small | Connexion | Nombre d'extension de tampon de commandes réseau lors de l'envoi des commandes de PHP vers MySQL. | mysqlnd alloue un tampon interne de commande/réseau de mysqlnd.net_cmd_buffer_size (php.ini) octets pour chaque connexion. Si une commande du protocole client-serveur MySQL, para exemple, COM_QUERY (requête normales), ne rentre pas dans le tampon, mysqlnd étendra le tampon de jusqu'à ce qui est nécessaire pour envoyer la commande. Quand le tampon est étendu pour une connexion, command_buffer_too_small sera incrémenté d'une unité. Si mysqlnd doit étendre le tampon au délà de sa taille initiale de mysqlnd.net_cmd_buffer_size (php.ini) octets pour la plupart des connexions, vous devriez considérer l'augmentation de la taille par défaut pour éviter les you should consider to increase the default size to avoid re-allocations. La taille par défaut du tampon est de 2048 octets en PHP 5.3.0. Dans les versions futures, ce sera 4ko ou plus par défaut. Cette valeur peut être changée soit via php.ini en ajustant le paramètre mysqlnd.net_cmd_buffer_size ou en utilisant mysqli_options(MYSQLI_OPT_NET_CMD_BUFFER_SIZE, int size). Il est recommandé de ne pas ajuster la taille du tampon en dessous de 4096 octets car mysqlnd l'utilise aussi pour lire certains paquets de communication de MySQL. En PHP 5.3.0, mysqlnd n'étendra pas le tampon si MySQL envoie un paquet plus grand que la taille courante du tampon. Par conséquent, mysqlnd n'est pas capable de décoder le paquet et l'application cliente recevra une erreur. Il y a seulement deux situations où le paquet peut être plus grand que la valeur par défaut de 2048 octets de mysqlnd.net_cmd_buffer_size en PHP 5.3.0 : le paquet transporte un message d'erreur très long ou le paquet gère des méta-données de colonne de COM_LIST_FIELD (mysql_list_fields()) et les méta-données viennent d'une chaine de caractères avec une valeur par défaut importante (plus de 1900 octets). Aucun rapport de bogue n'existe sur le sujet - ça doit arriver très rarement. Depuis PHP 5.3.2, mysqlnd n'autorise pas les tampons de moins de 4096 octets.
connection_reused |  |  |