13.8.3 Fonctions d'informations

BENCHMARK(count,expr)

La fonction BENCHMARK() exécute l'expression expr de manière répétée count fois. Elle permet de tester la vélocité de MySQL lors du traitement d'une requête. Le résultat est toujours 0 . L'objectif de cette fonction ne se voit que du côté client, qui permet à ce dernier d'afficher la durée d'exécution de la requête :

mysql> SELECT BENCHMARK(1000000,ENCODE("bonjour","au revoir")); +--------------------------------------------------+ | BENCHMARK(1000000,ENCODE("bonjour","au revoir")) | +--------------------------------------------------+ |                                                0 | +--------------------------------------------------+ 1 row in set (4.74 sec)

Le temps affiché est le temps côté client, et non pas les ressources processeurs consommées. il est conseillé d'utiliser BENCHMARK() plusieurs fois de suite pour interpréter un résultat, en dehors de charges ponctuelles sur le serveur.

CHARSET(str)

Retourne le jeu de caractères de la chaîne argument.

mysql> SELECT CHARSET('abc');         -> 'latin1' mysql> SELECT CHARSET(CONVERT('abc' USING utf8));         -> 'utf8' mysql> SELECT CHARSET(USER());         -> 'utf8'

CHARSET() a été ajouté en MySQL version 4.1.0.

COERCIBILITY(str)

Retourne la coercibilité de la collation de la chaîne argument.

mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);         -> 0 mysql> SELECT COERCIBILITY('abc');         -> 3 mysql> SELECT COERCIBILITY(USER());         -> 2

Les valeurs retournées possibles sont :

Coercibilité	Signification
0	Collation explicite
1	Par de collation
2	Collation implicite
3	Coercible

Les valeurs les plus faibles ont la plus haute priorité.

COERCIBILITY() a été ajouté en MySQL version 4.1.1.

COLLATION(str)

Retourne la collation du jeu de caractères de la chaîne argument.

mysql> SELECT COLLATION('abc');         -> 'latin1_swedish_ci' mysql> SELECT COLLATION(_utf8'abc');         -> 'utf8_general_ci'

COLLATION() a été ajouté en MySQL version 4.1.0.

CONNECTION_ID()

Retourne l'identifiant de connexion courant ( thread_id ). Chaque connexion a son propre identifiant unique.

mysql> SELECT CONNECTION_ID();         -> 23786

CONNECTION_ID() a été ajouté en MySQL version 3.23.14.

CURRENT_USER()

Retourne le nom d'utilisateur et le nom d'hôte de la session courante. Cette valeur correspond au compte qui a été utilisé durant l'identification auprès du serveur. Cela peut être différent des valeurs de USER() .

mysql> SELECT USER();         -> 'davida@localhost' mysql> SELECT * FROM mysql.user; ERROR 1044: Access denied for user: '@localhost' to database 'mysql' mysql> SELECT CURRENT_USER();         -> '@localhost'

Cet exemple montre que même si le client a indiqué le nom d'utilisateur davida (comme mentionné par la fonction USER() ), le serveur a identifié le client comme un utilisateur anonyme (comme indiqué par la fonction CURRENT_USER() ). Une situation qui arrive s'il n'y a aucun compte de listé dans les tables de droits pour davida . CURRENT_USER() a été ajouté en MySQL version 4.0.6.

DATABASE()

Retourne le nom de la base de données courante :

mysql> SELECT DATABASE();         -> 'test'

Si aucune base de données n'a été sélectionnée, DATABASE() retourne une chaîne vide. A partir de la version 4.1.1, elle retourne NULL .

FOUND_ROWS()

Une commande SELECT peut inclure une clause LIMIT pour restreindre le nombre de lignes qui sera retournée par le client. Dans certains cas, il est mieux de savoir combien de lignes une commande aurait retourné, sans la clause LIMIT , mais sans lancer à nouveau le calcul. Pour cela, ajoutez l'option SQL_CALC_FOUND_ROWS dans la commande SELECT , puis appelez FOUND_ROWS() après :

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name     -> WHERE id > 100 LIMIT 10; mysql> SELECT FOUND_ROWS();

Le second SELECT retourne un nombre indiquant combien de lignes le premier SELECT aurait retourné s'il n'avait pas été écrit avec une clause LIMIT .Notez que si vous utilisez SELECT SQL_CALC_FOUND_ROWS ... , MySQL calcule toutes les lignes dans la liste des résultats. Ainsi, c'est plus rapide si vous n'utilisez pas de clause LIMIT et que la liste des résultats n'a pas besoin d'être envoyée au client. Si la commande SELECT précédente n'inclut pas l'option SQL_CALC_FOUND_ROWS , alors FOUND_ROWS() pourrait retourner une valeur différente suivant que LIMIT est utilisé ou pas.

SQL_CALC_FOUND_ROWS et FOUND_ROWS() peuvent être pratiques dans des situations où vous devez limiter le nombre de lignes que la requête retourne, mais que vous devez tout de même connaître le nombre de ligne total, sans exécuter une seconde requête. Un exemple classique est un script web qui présente des résultats de recherche. En utilisant FOUND_ROWS() , vous connaîtrez facilement le nombre de lignes de résultat.

L'utilisation de SQL_CALC_FOUND_ROWS et FOUND_ROWS() est plus complexe pour les requêtes UNION que pour les commandes SELECT simples, car LIMIT peut intervenir plusieurs fois dans une commande UNION . Elle sera appliquée à différentes commandes SELECT de la commande UNION , ou globalement à l' UNION .

Le but de SQL_CALC_FOUND_ROWS pour UNION est de retourner le nombre de lignes qui aurait été retourné sans la clause globale LIMIT . Les conditions d'utilisation de SQL_CALC_FOUND_ROWS avec UNION sont :

Le mot clé SQL_CALC_FOUND_ROWS doit apparaître dans le premier SELECT de l' UNION .
La valeur de FOUND_ROWS() est exactement la même que si UNION ALL était utilisé. Si UNION sans ALL est utilisé, des réductions de doublons surviendront, et la valeur de FOUND_ROWS() sera approximative.
Si aucune clause LIMIT n'est présente dans UNION , SQL_CALC_FOUND_ROWS est ignoré et retourne le nombre de lignes dans la table temporaire créé durant le traitement de l' UNION .

SQL_CALC_FOUND_ROWS et FOUND_ROWS() sont disponibles à partir de la version 4.0.0 de MySQL.

LAST_INSERT_ID()

LAST_INSERT_ID(expr)

Retourne le dernier identifiant automatiquement généré par une colonne AUTO_INCREMENT .

mysql> SELECT LAST_INSERT_ID();         -> 195

Le dernier ID généré est conservé par le serveur pour chaque connexion. Un autre client ne la modifiera donc pas, même s'ils génèrent une autre valeur AUTO_INCREMENT de leur coté. Ce comportement permet de s'assurer que les actions des autres clients ne perturbe pas les actions du client en cours.

La valeur de LAST_INSERT_ID() ne sera pas modifiée non plus si vous modifiez directement la valeur d'une colonne AUTO_INCREMENT avec une valeur simple (c'est à dire, une valeur qui n'est ni NULL , ni 0).

Si vous insérez plusieurs lignes au même moment avec une requête INSERT , LAST_INSERT_ID() retourne la valeur de la première ligne insérée. La raison à cela est que cela rend possible la reproduction facilement la même requête INSERT sur d'autres serveurs.

Si vous utilisez une commande INSERT IGNORE et que la ligne est ignorée, le compteur AUTO_INCREMENT sera malgré tout incrémenté, et LAST_INSERT_ID() retournera une nouvelle valeur.

Si expr est donnée en argument à la fonction LAST_INSERT_ID() , alors la valeur de l'argument sera retourné par la fonction et sera enregistré comme étant la prochaine valeur retournée par LAST_INSERT_ID() . Cela peut être utilisé pour simuler des séquences :

Commencez par créer la table suivante :

mysql> CREATE TABLE sequence (id INT NOT NULL); mysql> INSERT INTO sequence VALUES (0);

Utilisez cette table pour générer des séquences de nombre comme ceci :
mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1); mysql> SELECT LAST_INSERT_ID();
La commande UPDATE incrémente le compteur de séquence, et fait que le prochain appel à LAST_INSERT_ID() va retourner une valeur différente. La commande SELECT lit cette valeur. La fonction C mysql_insert_id() peut aussi être utilisée pour lire la valeur. mysql_insert_id() .

Vous pouvez générer des séquences sans appeler la fonction LAST_INSERT_ID() , mais l'utilité d'utiliser cette fonction cette fois si est que la valeur ID est gérée par le serveur comme étant la dernière valeur générée automatiquement. (sécurité multi-utilisateur). Vous pouvez retrouver la nouvelle ID tout comme vous pouvez lire n'importe quelle valeur AUTO_INCREMENT dans MySQL. Par exemple, la fonction LAST_INSERT_ID() (sans argument) devrait retourner la nouvelle ID. La fonction C de l'API mysql_insert_id() peut être également utilisée pour trouver cette valeur.

Notez que la fonction mysql_insert_id() est incrémentée uniquement après des requêtes INSERT et UPDATE , donc, vous ne pouvez pas utiliser la fonction C de l'API pour trouver la valeur de LAST_INSERT_ID(expr) après avoir exécuté d'autres types de requêtes, comme SELECT ou bien SET .

SESSION_USER()

SESSION_USER() est un synonyme de USER() .

SYSTEM_USER()

SYSTEM_USER() est un synonyme de USER() .

USER()

Retourne le nom d'utilisateur et le nom d'hôte courant MySQL :

mysql> SELECT USER();         -> 'davida@localhost'

La valeur indique le nom d'utilisateur qui a été spécifié lors de l'identification avec le serveur MySQL, et l'hôte client avec lequel il est connecté. Avant la version 3.22.11, la fonction ne retournait pas le nom d'hôte. Vous pouvez extraire le nom d'utilisateur sans l'hôte avec la commande suivante :

mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);         -> 'davida'

Depuis MySQL version 4.1, USER() retourne la valeur au format utf8 . Assurez vous que la chaîne '@' est bien interprétée dans ce jeu de caractères :

mysql> SELECT SUBSTRING_INDEX(USER(),_utf8'@',1);         -> 'davida'

VERSION()

Retourne une chaîne indiquant la version courante du serveur MySQL :

mysql> SELECT VERSION();         -> '4.1.2-alpha-log'

Notez que si votre version se termine par -log , cela signifie que le système d'historique est actif.