7.3.12 Fonctions diverses

  • DATABASE() Retourne le nom de la base de données courante 
    mysql> select DATABASE();
        -> 'test'

    S'il n'y a pas de base de données courante, DATABASE() retourne une chaîne vide.

  • USER()
  • SYSTEM_USER()
  • SESSION_USER() Retourne le nom de l'utilisateur MySQL courant. 
    mysql> select USER();
        -> 'davida@localhost'

    Avec MySQL 3.22.11 ou plus récent, le nom de l'utilisateur courant contient le nom du de l'hôte client. On peut alors en extraire le nom du User. 

    mysql> select left(USER(),instr(USER(),"@")-1);
        -> 'davida'
  • PASSWORD(str) Calcule un mot de passe à partir du texte de str. C'est une fonction d'encryption utilisée par MySQL pour stocker les mots de passes dans la colonne Password, de la table des droits des utilisateurs. 
    mysql> select PASSWORD('badpwd');
        -> '7f84554057dd964b'

    Le cryptage de PASSWORD() n'est pas reversible. PASSWORD() effectue un cryptage différent de celui d'Unix. Il ne faut pas croire que si le mot de passe de MySQL et d'Unix sont les mêmes, alors les deux valeurs cryptées seront les mêmes. Voir ENCRYPT().

  • ENCRYPT(str[,salt]) Crypte la chaîne str en utilisant le cryptage d'Unix( crypt())l. Le grain de sel est une chaîne avec deux caractères. 
    mysql> select ENCRYPT("hello");
        -> 'VxuFAJXVARROc'

    Si la commande crypt() n'est pas disponible sur votre système, ENCRYPT()retournera NULL. ENCRYPT() n'utilise que les 8 premiers caractères de la chaîne, sur certains systèmes. Cela dépendra du comportement de l'appel système : crypt().

  • ENCODE(str,pass_str) Crypte la chaîne str en utilisant de mot de passe pass_str . Pour décrypter le résultat, il faut utiliser DECODE(). Le résultat est une chaîne binaire. Pour l'enregistrer, il faut l'affecter à une colonne de type BLOB .
  • DECODE(crypt_str,pass_str) Décrypte la chaîne cryptée crypt_str, en utilisant le mot de passe pass_str . crypt_str doit être une chaîne retournée par ENCODE().
  • MD5(string) Calcule la somme de vérification MD5 de ma chaîne. La valeur retournée est un nombre hexadécimal de 32 bits, utilisé comme clé. 
    mysql> select MD5("testing")
        -> 'ae2b1fca515949e5d54fb22b8ed95575'

    Cette fonction est issue de "RSA Data Security, Inc. MD5 Message-Digest Algorithm".

  • LAST_INSERT_ID([expression ]) Retourne la dernière valeur générée automatiquement lors de la mise à jour d'une colonne de type AUTO_INCREMENT Voir Section mysql_insert_id. 
    mysql> select LAST_INSERT_ID();
        -> 195

    Le dernier ID généré est conservé par le serveur, sur la base d'un par connexion. Il ne sera pas changé par un autre client. Il ne sera même pas changé par la mise à jour d'une colonne de type AUTO_INCREMENT. Si expression est donné comme argument à LAST_INSERT_ID() dans une clause , alors la valeur de l'argument est retournée, en tant que LAST_INSERT_ID(). Cela peut être utile pour simuler des séquences. Par exemple :

  • Création d'une table : 
    mysql> create table sequence (id int not null);
mysql> insert into sequence values (0);

    Alors la table peut être utilisée pour générer une séquence de nombre comme ceci : 

    mysql> update sequence set id=LAST_INSERT_ID(id+1);

    Il est possible de générer des séquences sans appeler LAST_INSERT_ID(), mais l'interêt de cette fonction et que l'ID est conservé par le serveur en tant que dernière valeur générée. Il est ainsi possible d'obtenir un nouvel ID comme lors de la lecture de n'importe quelle colonne de type AUTO_INCREMENT. Par exemple, LAST_INSERT_ID() (sans argument) retournera un nouvel ID . La méthode C API mysql_insert_id() peut aussi être utilisée pour obtenir une telle valeur.

  • FORMAT(X,D) Met le nombre X au format'#,###,###.##' avec D décimales. Si D vaut 0, le résultat n'aura ni décimales, ni virgule. 
    mysql> select FORMAT(12332.1234, 2);
        -> '12,332.12'
mysql> select FORMAT(12332.1,4);
        -> '12,332.1000'
mysql> select FORMAT(12332.2,0);
        -> '12,332'
  • VERSION() Retourne la version du serveur MySQL . 
    mysql> select VERSION();
        -> '3.22.19b-log'
  • GET_LOCK(str,timeout) Essaie d'obtenir le verrous nommé str , avec un timeout de timeout secondes. Retourne 1 si le verrous a pu être obtenu, 0 en cas d'échec, ou si une erreur est survenue (comme par exemple, plus de mémoire disponible, ou le thread a été tué par l'administrateur). Un verrou est libéré avec la fonction RELEASE_LOCK(), avec l'exécution de la fonction GET_LOCK() ou la mort du thread courant. Cette fonction peut être utilisée pour implémenter des verrous d'applications, ou simuler des verrous sur les enregistrements. 
    mysql> select GET_LOCK("lock1",10);
        -> 1
mysql> select GET_LOCK("lock2",10);
        -> 1
mysql> select RELEASE_LOCK("lock2");
        -> 1
mysql> select RELEASE_LOCK("lock1");
        -> NULL

    Il faut noter que le deuxième appel à RELEASE_LOCK()retourne NULL car le verrou "lock1" a été automatiquement libéré par le deuxième appel à GET_LOCK().

  • RELEASE_LOCK(str) Libère le verrous nommé str, obtenu par l'appel de GET_LOCK() . Retourne 1 si le verrous a bien été libéré, et 0 si il n'était pas mis par ce thread (dans ce cas, il reste verrouillé), et si ce verrous n'existe pas. Le verrous n'existe pas tant qu'il n'a pas été créer par GET_LOCK() ou si il a déjà été libéré.
  • BENCHMARK(count,expression ) La fonction de BENCHMARK exécute l'expression expression count fois. Cela permet de mesurer le temps que MySQL met à exécuter l'expression. Le résultat est toujours 0. Le temps mis pour l'exécution de la commande est disponible sur l'affichage du client MySQL. 
    mysql> select BENCHMARK(1000000,encode("hello","goodbye"));
+----------------------------------------------+
| BENCHMARK(1000000,encode("bonjour","ca va")) |
+----------------------------------------------+
|                                            0 |
+----------------------------------------------+
1 row in set (4.74 sec)

    Le temps affiché sur le client est le temps entre le début et la fin de l'exécution, et non pas le temps de travail du processeur. Il peut être nécessaire d'éxécuter plusieurs fois la commande, pour prendre en compte la charge de la machine.