La notion de fonction est importante pour le développeur, en complément des opérateurs que nous venons de voir, elle lui permet de faire des traitements plus ou moins complexes sur les colonnes des tables.
Comme pour les opérateurs, une fonction peut apparaître n’importe où dans un ordre SQL en lieu et place d’une colonne.
Fonctions de groupe
mysql> select max(i), c from isa;
ERROR 1140 (42000): In aggregated query without GROUP BY, expression #2 of SELECT list contains nonaggregated column ‘HR.isa.c’; this is incompatible with sql_mode=only_full_group_by
mysql> select max(i), c from ino;
ERROR 1140 (42000): In aggregated query without GROUP BY, expression #2 of SELECT list contains nonaggregated column ‘HR.ino.c’; this is incompatible with sql_mode=only_full_group_by
mysql> SELECT @@GLOBAL.sqlmode();
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ‘()’ at line 1
mysql> SELECT @@GLOBAL.sql_mode;
+———————————————————————————————————————–+
| @@GLOBAL.sql_mode |
+———————————————————————————————————————–+
| ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION |
+———————————————————————————————————————–+
1 row in set (0,00 sec)
mysql> SET sql_mode=(SELECT REPLACE(@@sql_mode,’ONLY_FULL_GROUP_BY’, »));
Query OK, 0 rows affected (0,01 sec)
mysql>
mysql> select max(i), c from ino;
+——–+——+
| max(i) | c |
+——–+——+
| 2 | b |
+——–+——+
1 row in set (0,01 sec)
Nous allons passer en revue dans ce paragraphe, les fonctions standards de MySQL, regroupées par catégorie: fonctions mathématiques, de traitement de chaînes de caractères, de dates et de conversion.
Il est possible et même souhaitable de créer des fonctions personnalisées, grâce à la commande SQL: CREATE FUNCTION. Cela ira enrichir la bibliothèque standard décrite ici.
Les fonctions mathématiques
Présentation des différentes fonctions mathématiques
ABS(X)
Retourne la valeur absolue de X.
mysql> SELECT ABS(-2);- > 2
ACOS(X)
Retourne l’arc cosinus de X, soit, la valeur de l’angle dont X est le cosinus. Retourne NULL si X n’est pas compris entre -1 et 1.
mysql> SELECT ACOS(1); -> 0.000000
ASIN(X)
Retourne l’arcsinus de X, soit, la valeur de l’angle dont le sinus est X. Retourne NULL si X n’est pas compris entre -1 et 1
mysql> SELECT ASIN(0); -> 0
ATAN(X)
Retourne l’arc tangente de X, soit, la valeur de l’angle dont la tangente est X.
mysql> SELECT ATAN(2); -> 1.107149
ATAN(Y,X), ATAN2(Y,X)
Retourne l’arc tangente de Y / X
mysql> SELECT ATAN2(PI(),0); -> 1.570796
CEILING(X), CEIL(X)
Retourne la valeur entière immédiatement supérieure à X.
mysql> SELECT CEILING(1.82);
-> 2
mysql> SELECT CEILING(-1.82);
-> -1
Notez que la valeur retournée sera de type BIGINT!
COS(X)
Retourne le cosinus de X
mysql> SELECT COS(PI());
-> -1.000000
COT(X)
Retourne la cotangente de X.
mysql> SELECT COT(1);
-> 0.64209
CRC32(expr) -> 32 bits non-signé
Calcule le paramètre d’entrée est une chaîne.
mysql> SELECT CRC32(‘DD’);
-> 2759662967
DEGREES(X)
Retourne X (en radian) converti en degrés.
mysql> SELECT DEGREES(2*PI());
-> 360.000000
EXP(X)
Exponentielle de X en base ‘e’
mysql> SELECT EXP(1);
-> 2.718281828459045 (eh oui! ca fait ‘e’)
FLOOR(X) -> BIGINT
Retourne la valeur entière immédiatement inférieure à X.
mysql> SELECT FLOOR(2.23);
-> 2
mysql> SELECT FLOOR(-2.23);
-> -3
LN(X), LOG(X)
Retourne le logarithme Népérien de X
mysql> SELECT LN(2);
-> 0.693147
LOG(X,B)
retourne le logarithme naturel de X en base B
mysql> SELECT LOG(2,16);
-> 4
LOG10(X)
Retourne le logarithme en base 10 de X.
mysql> SELECT LOG10(1000);
-> 3.000000
MOD(N,M), N % M, N MOD M
Modulo
mysql> SELECT MOD(5, 2);
-> 1
PI()
Retourne la valeur de pi! Par défaut, 5 décimales sont retournées
mysql> SELECT PI();
-> 3.141593
POW(X,Y), POWER(X,Y)
Retourne la valeur de X élevée à la puissance Y (Y peut être négatif)
mysql> SELECT POW(2,4);
-> 16.000000
RADIANS(X)
Retourne l’argument X (en degré) converti en radians.
mysql> SELECT RADIANS(180);
-> 3.14159
RAND(), RAND(N)
Retourne un nombre aléatoire compris entre 0 et 1. Si l’entier N est spécifié, il est utilisé comme initialisation du générateur.
mysql> SELECT RAND();
-> 0.7233482386203
mysql> SELECT RAND(10);
-> 0.16888261251047
mysql> SELECT RAND(10);
-> 0.16888261251047
ROUND(X), ROUND(X,D)
Retourne X, arrondi à un nombre à D décimales près.
mysql> SELECT ROUND(1.78);
-> 2
mysql> SELECT ROUND(1.378, 1);
-> 1.4
SIGN(X)
Retourne le signe deX. Respectivement -1, 0, ou 1, quand X est négatif, zéro, ou positif.
mysql> SELECT SIGN(-32);
-> -1
SIN(X)
Retourne le sinus de X (X en radians)
mysql> SELECT SIN(PI()/2);
-> 1.000000
SQRT(X)
Retourne la racine carrée de X.
mysql> SELECT SQRT(4);
-> 2.000000
TAN(X)
Retourne la tangente de X (X en radians)
mysql> select tan(pi()/4);
-> 0.9999999999999999
TRUNCATE(X,D)
Retourne X, tronqué à D décimales.
mysql> SELECT TRUNCATE(4.23,1);
-> 4.2
- Quelques exercices sur les fonctions mathématiques
Nous allons aborder à travers ces quelques exercices, SQL sous un angle un peu plus mathématique (cela tombe bien, pour des fonctions numériques!) et parfois un peu plus ludique…
Voici les énoncés (vous trouverez les solutions dans le paragraphe suivant):
- Afficher le nombre d’or (la moitié de (1+racine de 5))
- Afficher le nombre d’or (la moitié de (1+racine de 5))…sans utiliser la fonction racine
Truc: la racine nieme d’un nombre est la puissance 1 sur n de ce nombre
- Générer un nombre aléatoire compris entre 0 et Pi avec un SELECT
- Afficher avec un SELECT, le carré du sinus d’un angle x en radian (Avec x aléatoire compris entre 0 et Pi)
- Problème: Je pose 2g d’or sur la première case d’un échiquier, 4g sur la deuxième, 8g sur la troisième, 16g sur la quatrième et ainsi de suite sur toutes les cases. Quel poids d’or aurais-je sur la dernière case? Donner directement un résultat entier, en millions de tonnes, par un SELECT.
Et voici les solutions, avec si nécessaire quelques explications…
- Afficher le nombre d’or (la moitié de (1+racine de 5))
mysql> SELECT (1+SQRT(5))/2;
+——————-+
| (1+SQRT(5))/2 |
+——————-+
| 1.618033988749895 |
+——————-+
Afficher le nombre d’or (la moitié de (1+racine de 5))…sans utiliser la fonction racine
Truc: la racine nieme d’un nombre est la puissance 1 sur n de ce nombre
mysql> SELECT (1+POWER(5,0.5))/2;
+——————–+
| (1+POWER(5,0.5))/2 |
+——————–+
| 1.6180339887498947 |
+——————–+
Générer un nombre aléatoire compris entre 0 et Pi avec un SELECT
mysql> SELECT PI()*(RAND());
+——————-+
| PI()*(RAND()) |
+——————-+
| 2.564744536144507 |
+——————-+
Afficher avec un SELECT, le carré du sinus d’un angle x en radian (Avec x aléatoire compris entre 0 et Pi)
mysql> SELECT POWER(SIN( PI()*(RAND())) ,2) ;
+——————————-+
| POWER(SIN( PI()*(RAND())) ,2) |
+——————————-+
| 0.5150963139815667 |
+——————————-+
Problème: Je pose 2g d’or sur la première case d’un échiquier, 4g sur la deuxième, 8g sur la troisième, 16g sur la quatrième et ainsi de suite sur toutes les cases. Quel poids d’or aurais-je sur la dernière case? Donner directement un résultat entier, en millions de tonnes, par un SELECT.
Il y a 64 cases sur un échiquier. A l’évidence le nombre de grammes double toutes les cases, il y en a 2 puissance 1 sur la 1ere, 2 puissance 2 sur la 2eme, etc. et donc 2 puissance 64 sur la dernière.
1 tonne = 1 million de grammes; 1 million de tonnes = 1 million de million de grammes, soit 10 puissance 12 grammes. Il faudra donc diviser 2 puissance 64, par 10 puissance 12 pour obtenir le résultat exact.
On le ‘tronquera’ ensuite à 0 décimale:
mysql> SELECT TRUNCATE(POWER(2,64)/POWER(10,12),0) ‘millions de tonnes’;
+——————–+
| millions de tonnes |
+——————–+
| 18446744 |
+——————–+
On vérifie ici, si besoin était, que la fonction puissance de 2 est une fonction qui croit de manière excessivement rapide.
Les fonctions de traitement de chaînes de caractères
Nous allons détailler ici par ordre alphabétique, la syntaxe et les exemples associés, des fonctions qui portent sur les TYPES chaînes de caractères (CHAR, VARCHAR, TEXT, etc).
Présentation des différentes fonctions de traitement de chaînes
ASCII(STR)
Retourne le code ASCII (en décimal) du premier caractère de la chaîne STR.
mysql> SELECT ASCII(‘A’);
-> 65
BIN(N)
Retourne une chaîne de caractères avec la valeur binaire de N (N est un BIGINT).
mysql> select bin(32);
-> 100000
BIT_LENGTH(str)
Retourne le nombre de bits de la chaîne str.
mysql> SELECT BIT_LENGTH(‘texte’);
-> 40 ( 5 octest!)
CHAR(N,…)
retourne une chaîne de caractères, constituée des caractères, avec pour code ASCII la liste passée en paramètre
mysql> SELECT CHAR(77,121,83,81,’76’);
-> ‘MySQL’
CHAR_LENGTH(str) , CHARACTER_LENGTH(str)
Retourne le nombre de caractères de la chaîne str. (multiplié par N si la chaîne est en multi-octets(N).
mysql> SELECT CHAR_LENGTH(‘DD’);
-> 2
COMPRESS(string_to_compress)
Compresse une chaîne. (la bibliothèque zlib doit être installée, sinon, la valeur retournée est NULL).
mysql> SELECT LENGTH(COMPRESS(REPEAT(‘C’,100)));
-> 16 (on a gagné 84 octets!)
- Il est conseillé d’utiliser un type BLOB plutôt qu’un CHAR ou un VARCHAR pour stocker des chaînes compressées.
CONCAT(str1,str2,…)
Retourne la concaténation de STR1, STR2, …
mysql> SELECT CONCAT(‘Dare’, ‘de’, ‘vil’);
-> ‘Daredevil’
CONCAT_WS(separator, str1, str2,…)
Concaténation avec séparateur. Le premier argument est le séparateur
mysql> SELECT CONCAT_WS(« , », »1″, »2″, »3″);
-> 1,2,3
CONV(N,de_base,vers_base)
Convertit des nombres entre différentes bases
mysql> select conv(16,10,2);
-> 10000 (passage de 16 de base décimale en base 2)
ELT(N,str1,str2,str3,…)
Retourne le Neme élément d’une liste de chaînes
mysql> SELECT ELT(2, ‘Matt’, ‘Murdock’, ‘aka’, ‘Daredevil’);
-> ‘Murdock’
EXPORT_SET(bits,on,off,[séparateur,[nombre_de_bits]])
Retourne une chaîne dont tous les bits à 1 de N sont représentés par la chaîne « on », et les bits à 0 représentés par la chaîne « off ». Chaque chaîne est séparée par ‘séparateur’ (défaut, la virgule). Seul « nombre_de_bits » (défaut 64) « bits » est vérifié.
mysql> SELECT EXPORT_SET(15,’O’,’N’);
-> O,O,O,O,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
FIELD(str,str1,str2,str3,…)
Retourne le no d’occurence de la chaîne str dans la liste str1, str2, str3, …. Retourne 0 si str n’est pas trouvé.
mysql> SELECT FIELD(‘Daredevil’,’Matt’, ‘Murdock’, ‘aka’, ‘Daredevil’);
-> 4
FIND_IN_SET(str,strlist)
Comme FIELD, mais la liste de chaiînes est contenue dans une seule chaîne; strlist
mysql> SELECT FIND_IN_SET(‘Daredevil’,’Matt,Murdock,aka,Daredevil’);
-> 4
HEX(N_ou_S)
Renvoie la valeur Hexadécimale de N_ou_S qui est soit un nombre soit une chaîne.
mysql> SELECT HEX(15);
-> ‘F’
mysql> SELECT HEX(« ab »);
-> 6162
INSERT(str,pos,len,newstr)
Retourne une chaîne de caractères str, après avoir remplacé la portion de chaîne commençant à la position pos et de longueur len, par la chaîne newstr :
mysql> SELECT INSERT(‘Quadratique’, 4, 4, ‘tart’);
-> ‘Quatartic’ (Hum…Hum)
INSTR(str,substr) , LOCATE (substr, str)
Retourne la position de la première occurrence de la chaîne substr dans la chaîne str.
mysql> SELECT INSTR(‘Matt Murdock’, ‘Mur’);
-> 6
LEFT(str,n)
Retourne les n caractères les plus à gauche de la chaîne de caractères str.
mysql> SELECT LEFT(‘MattMurdock, 4);
-> ‘Matt’
LENGTH(str), OCTET_LENGTH(str)
Retourne la taille de la chaîne str, mesurée en octets (multipliée par N si multi octest)
mysql> SELECT LENGTH(‘texte’);
-> 5
LOAD_FILE(nom_fic)
Lit le fichier nom_fic et retourne son contenu sous la forme d’une chaîne de caractères (permet de remplir un LOB par exemple)
mysql> UPDATE tbl_name
SET mon_lob=LOAD_FILE(« /tmp/mon_image.jpg »)
WHERE no_image=112;
- les droits nécessaires pour le lire. En cas de problème de lecture, la fonction LOAD_FILE retourne NULL
LOCATE (substr, str), POSITION(substr IN str)
Localise la position de SUBSTR dans STR
mysql> select locate(‘D’,’ADMIS’);
-> 2
- Le fichier doit se trouver sur le serveur qui héberge MySQL, et on doit avor
LOWER(str), LCASE(str)
Retourne la chaîne str en minuscule, en fonction du jeu de caractères courant
mysql> SELECT LOWER(‘MINUSCULE’);
-> ‘minuscule’ (CQFD)
LPAD(str,len,padstr)
Complète à gauche la chaîne STR par la chaîne padstr.
mysql> SELECT LPAD(‘L’,5,’X’);
-> ‘XXXXL’
LTRIM(str)
supprime les espaces initiaux de STR:
mysql> SELECT LTRIM(‘ ma_chaine’);
-> ‘ma_chaine’
MAKE_SET(N, str1, str2,…)
Retourne une liste (séparées par des virgules) constituée de chaînes qui ont le no de la décomposition binaire de N
mysql> SELECT MAKE_SET(3,’a’,’b’,’c’,’d’);
-> ‘a,b’ (car 3 en binaire c’est 0011 lu de droite à gauche)
OCT(N)
Retourne une chaîne contenant la valeur octale de N.
mysql> SELECT OCT(12);
-> ’14’ (car 12 en décimal c’est 8+4 en octal)
ORD(str)
Si le premier caractère de la chaîne str est un caractère multi-octets, la fonction retourne: (octet1 * 256) + (octet * 256^2) + (octet3 * 256^3) …
Sinon retourne la même valeur que ASCII():
mysql> SELECT ORD(‘A’);
-> 65
QUOTE(str)
Echappe (rajoute un ‘\’ devant) les caractères spéciaux d’une chaîne pour être exploitable dans une requête SQL. Les caractères spéciaux sont la simple cote (‘), l’anti-slash (‘\’), ASCII NUL, et le Contrôle-Z.
mysql> SELECT QUOTE(« De l’église »);
-> ‘De l\’église’
REPEAT(str,count)
répète COUNT fois la chaîne str
mysql> SELECT REPEAT(‘Hop’, 3);
-> ‘HopHopHop’
REPLACE(str,from_str,to_str)
Remplace dans str toutes les occurrences de la chaîne from_str sont par la chaîne to_str:
mysql> SELECT REPLACE(‘Myth Murdock’,’Myth’,’Matt’);
-> ‘WwWwWw.mysql.com’
REVERSE(str)
Inverse l’ordre des caractères de la chaîne str:
mysql> SELECT REVERSE(‘abcdef’);
-> ‘fedcba’
RIGHT(str,N)
Retourne les N caractères les plus à droite de la chaîne de caractères str:
mysql> SELECT RIGHT(‘Daredevil’, 5);
-> ‘devil’
RPAD(str,len,padstr)
Complète à droite la chaîne str avec padstr, jusqu’à LEN (c’est le symétrique de LPAD)
mysql> SELECT RPAD(‘Ouf’,5,’!!’);
-> ‘Ouf!!’
RTRIM(str)
Supprime les espaces finaux de str:
mysql> SELECT RTRIM(‘ma_chaine ‘);
-> ‘ma_chaine’
SOUNDEX(str)
Quantifie la sonorité d’une chaîne. Deux sonorités proches auront des valeurs SOUNDEX proches:
mysql> SELECT SOUNDEX(‘Allo’);
-> A400
mysql> SELECT SOUNDEX(‘Halo’);
-> H400
expr1 SOUNDS LIKE expr2
équivaut à SOUNDEX(expr1)=SOUNDEX(expr2)
SPACE(N)
Remplit une chaîne de N espaces:
mysql> SELECT SPACE(4);
-> ‘ ‘
SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,N), SUBSTRING(str FROM pos FOR N)
Retourne une chaîne de N caractères de long de la chaîne str, à partir de la position pos. La syntaxe ANSI SQL92 utilise une variante de la fonction FROM:
mysql> SELECT SUBSTRING(‘Anticonstitutionnellement,5);
-> ‘constitutionnellement’
SUBSTRING_INDEX (str,delimiteur,count) , MID(str,pos,len)
Retourne une portion de la chaîne de caractères str, située avant COUNT occurrences du délimiteur DELIMITEUR. Si COUNT est positif, tout ce qui précède le délimiteur final sera retourné. Si COUNTest négatif, tout ce qui suit le délimiteur final sera retourné:
mysql> SELECT SUBSTRING_INDEX(‘www.marvel-comics.com’, ‘.’, 2);
-> ‘www.marvel-comics’
TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)
Retourne la chaîne de caractères str dont tous les préfixes et/ou suffixes remstr ont été supprimés. LEADING: les préfixes, TRAILING:les suffixes, BOTH (c’st le défaut) les 2. Si REMSTR n’est pas spécifié, les espaces sont supprimés:
mysql> SELECT TRIM(‘ toto ‘);
-> ‘toto’
mysql> SELECT TRIM(LEADING ‘x’ FROM ‘xxxbarxxx’);
UNCOMPRESS(string_to_uncompress)
Décompresse une chaîne compressée avec COMPRESS(). Si la chaîne d’entrée n’est pas une valeur compressée, le résultat est NULL. Cette fonction requiert la bibliothèque ZLIB. Sinon, la valeur retournée est NULL:
mysql> SELECT UNCOMPRESS(COMPRESS(‘ma_chaine’));
-> ‘ma_chaine’
UNCOMPRESSED_LENGTH(compressed_string)
Retourne la taille de la chaîne avant compression.
mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT(‘ABCD’)));
-> 4
UNHEX(str)
La réciproque de HEX(string). Chaque paire de chiffres hexadécimaux sont interprétées comme des nombres, et sont convertis en caractère:
mysql> SELECT UNHEX(‘506174726965’);
-> Patrie
UPPER(str), UCASE(str)
Passe str en majuscules, en fonction du jeu de caractères courant. (Par défaut, ISO-8859-1 Latin1):
mysql> SELECT UPPER(‘majuscule’);
-> ‘MAJUSCULE’
- Quelques exercices pratiques sur les chaînes de caractères
- Liste des employés du service no 20 avec leur Job tronqué au 3eme caractère inclus. On utilisera 2 fonctions différentes pour ce faire:
- On veut afficher une partie de la table de la façon suivante. Trouvez le SELECT correspondant.
+————————————————————–+
| Salut |
+————————————————————–+
| Hey BAILLARGEON tu gagnes quand meme 800.00 Euros, par mois! |
| Hey FRANCHI tu gagnes quand meme 1600.00 Euros, par mois! |
| Hey OUVRARD tu gagnes quand meme 1250.00 Euros, par mois! |
…
- Liste des noms des employés avec la première lettre en majuscule et le reste en minuscule.
Truc: on pourra utiliser par exemple LEFT(), RIGHT(), LOWER() et LENGTH().
Solutions:
- Liste des employés du service no 20 avec leur Job tronqué au 3eme caractère inclus. On utilisera 2 fonctions différentes pour ce faire:
1ere solution avec LEFT():
mysql> SELECT nom, LEFT(job,3) FROM employes
-> WHERE no_service=20;
+————-+————-+
| nom | LEFT(job,3) |
+————-+————-+
| BAILLARGEON | EMP |
| MURDOCK | MAN |
| GORLIN | ANA |
| PARKER | EMP |
| GRIM | ANA |
+————-+————-+
5 rows in set (0.00 sec)
2eme solution avec par exemple SUBSTRING():
mysql> SELECT nom, SUBSTRING(job,1,3) FROM employes
-> WHERE no_service=20;
+————-+——————–+
| nom | SUBSTRING(job,1,3) |
+————-+——————–+
| BAILLARGEON | EMP |
| MURDOCK | MAN |
| GORLIN | ANA |
| PARKER | EMP |
| GRIM | ANA |
+————-+——————–+
5 rows in set (0.00 sec)
- On veut afficher une partie de la table de la façon suivante. Trouvez le SELECT correspondant.
+————————————————————–+
| Salut |
+————————————————————–+
| Hey BAILLARGEON tu gagnes quand meme 800.00 Euros, par mois! |
| Hey FRANCHI tu gagnes quand meme 1600.00 Euros, par mois! |
| Hey OUVRARD tu gagnes quand meme 1250.00 Euros, par mois! |
…
Il suffit de concaténer Chaînes de caractères et colonnes, sans oublier les espaces pour la lisibilité du résultat:
mysql> SELECT CONCAT(‘Hey ‘,nom,’ tu gagnes quand meme ‘,
-> salaire,’ Euros, par mois!’) AS Salut
-> FROM employes;
+————————————————————–+
| Salut |
+————————————————————–+
| Hey BAILLARGEON tu gagnes quand meme 800.00 Euros, par mois! |
| Hey FRANCHI tu gagnes quand meme 1600.00 Euros, par mois! |
| Hey OUVRARD tu gagnes quand meme 1250.00 Euros, par mois! |
| Hey MURDOCK tu gagnes quand meme 2975.00 Euros, par mois! |
| Hey MARTIN tu gagnes quand meme 1250.00 Euros, par mois! |
| Hey PIANETTI tu gagnes quand meme 2850.00 Euros, par mois! |
| Hey DELEGLISE tu gagnes quand meme 2450.00 Euros, par mois! |
| Hey GORLIN tu gagnes quand meme 3000.00 Euros, par mois! |
| Hey CHIRAC tu gagnes quand meme 5000.00 Euros, par mois! |
| Hey HULK tu gagnes quand meme 1500.00 Euros, par mois! |
| Hey PARKER tu gagnes quand meme 1100.00 Euros, par mois! |
| Hey XAVIER tu gagnes quand meme 950.00 Euros, par mois! |
| Hey GRIM tu gagnes quand meme 3000.00 Euros, par mois! |
| Hey LEE tu gagnes quand meme 1300.00 Euros, par mois! |
+————————————————————–+
14 rows in set (0.00 sec)
- Liste des noms des employés avec la première lettre en majuscule et le reste en minuscule.
Truc: on pourra utiliser par exemple LEFT(), RIGHT(), LOWER() et LENGTH().
mysql> SELECT CONCAT(LEFT(nom,1),
-> LOWER(RIGHT(nom,LENGTH(nom)-1))) Majuscule
-> FROM employes;
+————-+
| Majuscule |
+————-+
| Baillargeon |
| Franchi |
| Ouvrard |
| Murdock |
| Martin |
| Pianetti |
| Deleglise |
| Gorlin |
| Chirac |
| Hulk |
| Parker |
| Xavier |
| Grim |
| Lee |
+————-+
14 rows in set (0.00 sec)
- Les fonctions de traitement de DATE
Nous allons pour finir décrire les fonctions qui peuvent être utilisées pour manipuler les valeurs temporelles. Voir le chapitre 5 pour plus d’informations sur le type DATE.
- Les fonctions utilisant des dates acceptent les valeurs de type DATETIME et ignore la partie horaire. Les fonctions utilisant des heures acceptent les valeurs littérales et ignorent la partie date.
- Présentation des différentes fonctions DATE
ADDDATE(date,INTERVAL expr type), DATE_ADD(date,INTERVAL expr type, ADDDATE(expr,days)
Ajoute une quantité de temps à une DATE.
mysql> SELECT DATE_ADD(‘2012-02-28’, INTERVAL 2 DAY);
-> ‘2012-03-01’ (on ajoute 2 jours maisil y a un 29 février car 2012 est bissextile)
mysql> SELECT DATE_ADD(‘2012-02-28’, INTERVAL 2 MONTH);
-> 2012-04-28(cette fois on ajoute 2 mois) |
ADDTIME(expr,expr2)
ADDTIME() ajoute expr2 à expr et retourne le résultat. expr est une expression de type DATE ou DATETIME, et expr2 est une expression de type TIME.
mysql> SELECT ADDTIME(« 1997-12-31 23:59:59.999999 », « 1 1:1:1.000002 »);
-> ‘1998-01-02 01:01:01.000001′
mysql> SELECT ADDTIME(« 01:00:00.999999 », « 02:00:00.999998 »);
-> ’03:00:01.999997’
ADDTIME() a été ajouté en MySQL 4.1.1.
CURDATE(), CURRENT_DATE
Retourne la date courante au format ‘YYYY-MM-DD’ ou YYYYMMDD, suivant le contexte numérique ou chaîne :
mysql> SELECT CURDATE();
-> ‘1997-12-15’
mysql> SELECT CURDATE() + 0;
-> 19971215
CURRENT_DATE, CURRENT_DATE()
CURRENT_DATE et CURRENT_DATE() sont synonymes de CURDATE().
CURTIME(), CURRENT_TIME, CURRENT_TIME()
Donne l’heure courante au format ‘HH:MM:SS’ ou HHMMSS suivant que le résultat est de type numérique ou chaîne:
mysql> SELECT CURTIME();
-> ’13:00:21′
mysql> SELECT CURTIME() + 1; (l’ajout d’un nombre force le résultat en numérique)
-> 130021
CURRENT_TIMESTAMP, CURRENT_TIMESTAMP()
Voir plus loin la fonction NOW()
DATE(expr)
Extrait la partie date de l’expression expr. ‘expr’ peut être de type DATE ou DATETIME: