(1) Fonctions sur les bits
mySQL utilise l'arithmétique des BIGINT (64-bits) pour les opérations sur les bits. Ces opérateurs travaillent donc sur 64 bits.
|
OU bit-à-bit (OR)
mysql> SELECT 29 | 15;
-> 31
Le résultat est un entier de 64 bits non signé.
&
ET bit-à-bit (AND)
mysql> SELECT 29 & 15;
-> 13
Le résultat est un entier de 64 bits non signé.
^
XOR bit-à-bit
mysql> SELECT 1 ^ 1;
-> 0
mysql> SELECT 1 ^ 0;
-> 1
mysql> SELECT 11 ^ 3;
-> 8
Le résultat est un entier de 64 bits non signé.
<<
Décale les bits de l'entier (BIGINT) sur la gauche : mysql> SELECT 1 << 2;
-> 4
Le résultat est un entier de 64 bits non signé.
>>
Décale les bits de l'entier (BIGINT) sur la droite : mysql> SELECT 4 >> 2;
-> 1
Le résultat est un entier de 64 bits non signé.
~
Inverse tous les bits :
mysql> SELECT 5 & ~1;
-> 4
Le résultat est un entier de 64 bits non signé.
BIT_COUNT(N)
Retourne le nombre de bits non nuls de l'argument N : mysql> SELECT BIT_COUNT(29);
-> 4 (2) Fonctions diverses 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éléctionnée, DATABASE() retourne une chaîne vide.
USER() - SYSTEM_USER() - SESSION_USER() Retourne l'utilisateur mySQL courant :
mysql> SELECT USER();
-> 'davida@localhost'
A partir de la version 3.22.11 de mySQL, cette fonction inclut le nom de l'hôte du client tout comme le nom de l'utilisateur. Vous pouvez extraire le nom de l'utilisateur comme ceci (fonctionne également si le nom de l'hôte est présent) :
mysql> SELECT SUBSTRING_INDEX(USER(),"@",1);
-> 'davida' PASSWORD(str)
Calcule un mot de passe chiffré à partir de la chaîne str. C'est cette fonction qui est utilisé pour encrypter les mots de passes mySQL pour être stockés dans une colonne de type Password de la table user :
mysql> SELECT PASSWORD('badpwd');
-> '7f84554057dd964b'
Le chiffrage par PASSWORD() n'est pas réversible. PASSWORD() n'est pas un chiffrage comparable à la fonction Unix de chiffrage. Si votre mot de passe Unix et votre mot de passe mySQL sont identiques, il n'est ABSOLUMENT pas certain que Unix et mySQL le chiffreront de la même façon. Voir ENCRYPT().
ENCRYPT(str[,salt])
Chiffre la chaîne str en utilisant la fonction crypt(). L'argument salt doit être une chaîne de deux caractères. (A partir de la version 3.22.16, l'argument salt peut être plus long que deux caractères.) :
mysql> SELECT ENCRYPT("hello");
-> 'VxuFAJXVARROc'
Si la fonction crypt() n'est pas disponible sur votre système, la fonction ENCRYPT() retourenra toujours NULL. La fonction ENCRYPT() conserve uniquement les 8 premiers caractères de la chaîne str, au moins, sur certains système. Le comportement exact est directement déterminé par la fonction système crypt() sous-jacente.
ENCODE(str,pass_str)
Chiffre la chaîne str en utilisant la clé pass_str. Pour déchiffrer le résultat, utilisez la fonction DECODE(). Le résultat est une chaîne binaire de la même longueur que string. Si vous voulez sauvegarder le résultat dans une colonne, utilisez une colonne de type BLOB.
DECODE(crypt_str,pass_str)
Déchiffre la chaîne chiffrée crypt_str en utilisant la clé pass_str. crypt_str doit être une chaîne qui a été renvoyée par la fonction ENCODE().
MD5(string)
Calcul la somme de vérification MD5 de la chaîne string. La valeur retournée est un entier hexadécimal de 32 caractères qui peut être utilisé, par exemple, comme clé de hachage :
mysql> SELECT MD5("testing");
-> 'ae2b1fca515949e5d54fb22b8ed95575'
C'est l'algorithme RSA ("RSA Data Security, Inc. MD5 Message-Digest Algorithm").
SHA1(string) - SHA(string)
Calcul la somme de vérification SHA1 160 bit de la chaîne string, comme décrit dans la RFC 3174 (Secure Hash Algorithm). La valeur retournée est un entier exadécimal de 40 caractères, ou bien NULL dans le cas où l'argument vaut NULL. Une des possibilités d'utilisation de cette fonction est le hachage de clé. Vous pouvez aussi l'utilisé comme fonction de cryptographie sûre pour stocker les mots de passe.
mysql> SELECT SHA1("abc");
-> 'a9993e364706816aba3e25717850c26c9cd0d89d'
La fonction SHA1() a été ajoutée dans la version 4.0.2 de mySQL et peut être considérée comme une méthode de cryptographie plus sûre que la fonction MD5(). La fonction SHA() est un alias de la fonction SHA1().
AES_ENCRYPT(string,key_string) - AES_DECRYPT(string,key_string)
Ces fonctions permettent le chiffrement/déchiffrement de données utilisant l'algorithme AES (Advanced Encryption Standard), anciennement connu sous le nom de Rijndael. Une clé de 128 bits est utilisé pour le chiffrement, mais vous pouvez l'étendre à 256 bits en patchant la source.
Nous avons choisi 128 bits parce que c'est plus rapide et assez sécurisé. Les arguments peuvent être de n'importe quelle taille. Si l'un des arguments est NULL, le résultat de cette fonction sera NULL. Vu que AES est un algorithme de niveau bloc, le capitonnage est utilisé pour chiffrer des chaînes de longueur inégales et donc, la longueur de la chaîne résultante peut être calculée comme ceci : 16*(trunc(string_length/16)+1). Si la fonction AES_DECRYPT() détecte des données invalides ou un capitonnage incorrect, elle retournera NULL. Il est également possible que la fonction AES_DECRYPT() retourne une valeur différente de NULL (valeur incohérente) si l'entrée de données ou la clé est invalide. Vous pouvez utiliser les fonctions AES pour stocker des données sous une forme chiffrée en modifiant vos requêtes:
INSERT INTO t VALUES (1,AES_ENCRYPT("text","password"));
Vous pouvez obtenir encore plus de sécurité en évitant de transférer la clé pour chaque requête, en la stockant dans une variable sur le serveur au moment de la connexion :
SELECT @password:="my password";
INSERT INTO t VALUES (1,AES_ENCRYPT("text",@password));
Les fonctions AES_ENCRYPT() et AES_DECRYPT() ont été ajoutées dans la version 4.0.2 de mySQL et peuvent être considérées comme étant les fonctions de cryptographie les plus sûres disponibles actuellement dans mySQL.
DES_ENCRYPT(string_to_encrypt [, (key_number | key_string) ] )
Chiffre la chaîne avec la clé donnée en utilisant l'algorithme DES. Notez que cette fonction fonctionne uniquement si vous avez configuré mySQL avec le support SSL. La clé de hachage utilisée est choisie en suivant les recommandations suivantes :
Argument Description
Un seul argument La première clé de des-key-file est utilisée.
Un numéro de clé Le numéro de la clé donnée (0-9) de des-key-file est utilisée.
Une chaîne La chaîne donnée key_string doit être utilisé pour chiffrer string_to_encrypt.
La chaîne retournée doit etre une chaîne binaire où le premier caractère doit être CHAR(128 | key_number). Le nombre 128 a été ajouté pour reconnaître facilement une clé de hachage. Si vous utilisez une chaîne comme clé, key_number doit être 127. Si une erreur survient, la fonction retournera NULL. La longueur de la chaîne de résultat doit être : new_length=
org_length + (8-(org_length % 8))+1. des-key-file a le format suivant : key_number des_key_string
key_number des_key_string
Chaque key_number doit être un nombre dans l'intervalle 0 à 9. Les lignes dans le fichier peuvent être dans n'importe quel ordre. des_key_string est la chaîne qui permettera le chiffrage du message. Entre le nombre et la clé, il doit y avoir au moins un espace. La première clé est la clé par défaut qui sera utilisé si vous ne spécifiez pas d'autres clés en arguments de la fonction DES_ENCRYPT(). Vous pouvez demander à mySQL de lire de nouvelles valeurs de clé
dans le fichier de clés avec la commande FLUSH DES_KEY_FILE. Cela requiert le privilège Reload_priv. Un des bénéfices d'avoir une liste de clés par défaut est que cela donne aux applications la possibilité de regarder l'existence de la valeur chiffrée de la colonne, sans pour autant donner la possibilité à l'utilisateur final de déchiffrer ces valeurs.
mysql> SELECT customer_address FROM customer_table WHERE
crypted_credit_card = DES_ENCRYPT("credit_card_number");
DES_DECRYPT(string_to_decrypt [, key_string])
Déchiffre une chaîne chiffrée à l'aide de la fonction DES_ENCRYPT(). Notez que cette fonction fonctionne uniquement si vous avez configuré mySQL avec le support SSL. Si l'argument key_string n'est pas donné, la fonction DES_DECRYPT() examine le premier bit de la chaîne chiffrée pour déterminer le numéro de clé DES utilisé pour chiffrer la chaîne originale, alors la clé est lu dans le fichier des-key-file pour déchiffrer le message. Pour pouvoir utiliser cela, l'utilisateur doit avoir le privilège SUPER. Si vous passé l'argument key_string à cette fonction, cette chaîne est utilisée comme clé pour déchiffrer le message. Si la chaîne string_to_decrypt ne semble pas être une chaîne chiffrée, mySQL retournera la chaîne string_to_decrypt. Si une erreur survient, cette fonction retourne NULL.
LAST_INSERT_ID([expr])
Retourne la dernière valeur générée automatiquement qui a été insérée dans une colonne de type 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 le modifiera donc pas. Il ne sera pas modifié 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 de cela est de rendre possible de reproduire facilement la même requête INSERT sur d'autres serveurs. Si expr est donnée en argument à la fonction LAST_INSERT_ID(), alors la valeur de l'argument sera retournée par la fonction et sera enregistrée 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);
Alors cette table peut être utilisée pour générer des séquences de nombres, comme ceci : mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
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.
FORMAT(X,D)
Formate l'argument X en un format comme '#,###,###.##', arrondi à D décimales. Si D vaut
0, le résultat n'aura ni séparateur décimal, ni partie décimale : mysql> SELECT FORMAT(12332.123456, 4);
-> '12,332.1235'
mysql> SELECT FORMAT(12332.1,4);
-> '12,332.1000'
mysql> SELECT FORMAT(12332.2,0);
-> '12,332' VERSION()
Retourne une chaîne indiquant la version courante du serveur mySQL : mysql> SELECT VERSION();
-> '3.23.13-log'
Notez que si votre version se termine par -log, cela signifie que le système d'historique est actif.
CONNECTION_ID()
Retourne l'identifiant de connexion courant (thread_id). Chaque connexion a son propre identifiant unique :
mysql> SELECT CONNECTION_ID();
-> 1
GET_LOCK(str,timeout)
Tente de poser un verrou nommé str, avec un délai d'expiration (timeout) exprimé en seconde. Retourne 1 si le verrou a été posé avec succès, 0 si il n'a pas pu être posé avant l'expiration du délai et NULL si une erreur est survenu (comme par exemple un manque de mémoire, ou la mort du thread lui-même, par mysqladmin kill). Un verrou sera levé lorsque vous exécuterez la commande RELEASE_LOCK(), GET_LOCK() ou si le thread se termine.
Cette fonction peut être utilisée pour implémenter des verrous applicatifs ou pour simuler des verrous de lignes. Les requêtes concurentes des autres clients de même nom seront bloquées ; les clients qui s'entendent sur un nom de verrou peuvent les utiliser pour effectuer des verrouillages coopératifs :
mysql> SELECT GET_LOCK("lock1",10);
-> 1
mysql> SELECT IS_FREE_LOCK("lock2");
-> 1
mysql> SELECT GET_LOCK("lock2",10);
-> 1
mysql> SELECT RELEASE_LOCK("lock2");
-> 1
mysql> SELECT RELEASE_LOCK("lock1");
-> NULL
Notez 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 verrou nommé str, obetnu par la fonction GET_LOCK(). Retourne 1 si le verrou a bien été libéré, 0 si le verrou n'a pas été libéré par le thread (dans ce cas, le verrou reste posé) et NULL si le nom du verrou n'existe pas. Le verrou n'existe pas si il n'a pas été obtenu par la fonction GET_LOCK() ou si il a déjà été libéré. La commande DO est utilisable avec RELEASE_LOCK().
IS_FREE_LOCK(str)
Regarde si le verrou nommé str peut être librement utilisé (i.e., non verrouillé). Retourne 1 si le verrou est libre (personne ne l'utilise), 0 si le verrou est actuellement utilisé et NULL si une erreur survient (comme un argument incorrect).
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é dde 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.
INET_NTOA(expr)
Retourne l'adresse réseau (4 ou 8 octets), de l'expression numérique exp : mysql> SELECT INET_NTOA(3520061480);
-> "209.207.224.40"
INET_ATON(expr)
Retourne un entier qui représente l'expression numérique de l'adresse réseau. Les adresses peuvent être des entiers de 4 ou 8 octets.
mysql> SELECT INET_ATON("209.207.224.40");
-> 3520061480
Le nombre généré est toujours dans l'ordre des octets réseau ; par exemple, le nombre précédent est caculé comme ceci : 209*256^3 + 207*256^2 + 224*256 +40.
MASTER_POS_WAIT(log_name, log_pos)
Bloque le maître jusqu'à ce que l'esclave atteigne une position donnée dans le fichier d'historique principal, durant une réplication. Si l'historique principal n'est pas initialisé, retourne NULL. Si l'esclave n'est pas démarré, le maître restera bloqué jusqu'à ce que l'esclave soit démarré et ai atteint la position demandée. Si l'esclave a déjà dépassé cette position, la fonction se termine immédiatement. La valeur retournée est le nombre d'évènements qui a du être traité pour atteindre la position demandée, ou NULL en cas d'erreur. Cette fonction est très utile pour contrôler la synchronisation maître-esclave, mais elle a été initialement écrite pour faciliter les tests de réplications.
FOUND_ROWS()
Retourne le nombre de lignes que la dernière commande SELECT SQL_CALC_FOUND_ROWS ... a retourné, si aucune limite n'a été défini par LIMIT.
mysql> SELECT SQL_CALC_FOUND_ROWS * FROM nom_de_table WHERE id > 100 LIMIT 10;
mysql> SELECT FOUND_ROWS();
Le second SELECT retourne un nombre indiquant combien de lignes le premier SELECT aurait
retourné si il n'avait pas été écrit avec une clauseLIMIT. 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. SQL_CALC_FOUND_ROWS est utilisable à partir de la version 4.0.0 de mySQL.