SQL – Fonctions de date
Le tableau suivant présente une liste de toutes les fonctions importantes liées à la date et à l’heure disponibles via SQL. Il existe diverses autres fonctions prises en charge par votre SGBDR. La liste donnée est basée sur le SGBDR MySQL.
| Numéro d’ordre. | Fonction & Description |
|---|---|
| 1 | ADDDATE()
Ajoute des dates |
| 2 | ADDTIME()
Ajoute de l’heure |
| 3 | CONVERT_TZ()
Convertit d’un fuseau horaire à un autre |
| 4 | CURDATE()
Retourne la date du jour |
| 5 | CURRENT_DATE(), CURRENT_DATE
Synonymes de CURDATE() |
| 6 | CURRENT_TIME(), CURRENT_TIME
Synonymes de CURTIME() |
| 7 | CURRENT_TIMESTAMP(), CURRENT_TIMESTAMP
Synonymes de NOW() |
| 8 | CURTIME()Retourne l’heure actuelle |
| 9 | DATE_ADD()
Ajoute deux dates |
| 10 | DATE_FORMAT()
Formate la date comme spécifié |
| 11 | DATE_SUB()
Soustraction de deux dates |
| 12 | DATE()
Extrait la partie date d’une expression de date ou de datetime |
| 13 | DATEDIFF()
Soustraction de deux dates |
| 14 | DAY()
Synonyme de DAYOFMONTH() . pour DAYOFMONTH() |
| 15 | DAYNAME()
Retourne le nom du jour de la semaine |
16 | DAYOFMONTH()
Retourne le jour du mois (1-31) |
| 17 | DAYOFWEEK()
Retourne l’indice du jour de la semaine de l’argument |
| 18 | DAYOFYEAR()
Retourne le jour de l’année (1-366) |
| 19 | EXTRACT
Extrait une partie d’une date |
| 20 | FROM_DAYS()
Convertit un numéro de jour en date |
| 21 | FROM_UNIXTIME()
Formate la date en tant que un timestamp UNIX |
| 22 | HOUR()
Extrait l’heure |
| 23 | |
| 24 | LOCALTIME(), LOCALTIME
Synonyme de NOW() |
| 25 | LOCALTIMESTAMP, LOCALTIMESTAMP()
Synonyme de NOW() |
| 26 | . MAKEDATE()
Crée une date à partir de l’année et du jour de l’année |
| 27 | . MAKETIME
MAKETIME() |
| 28 | MICROSECOND()Retourne les microsecondes de l’argument |
| 29 | MINUTE()
Retourne la minute de l’argument |
| 30 | MONTH()
Retourne le mois à partir de la date mois de la date passée |
| 31 | MONTHNAME()
Retourne le nom du mois |
| 32 | NOW()
Retourne la date et l’heure actuelles et l’heure actuelles |
| 33 | PERIOD_ADD()
Ajoute une période à une année-mois |
| 34 | PERIOD_DIFF()
Retourne le nombre de mois entre les périodes |
| 35 | QUARTER()
Retourne le trimestre à partir d’un argument date |
| 36 | SEC_TO_TIME()
Convertit les secondes en ‘HH :MM :SS’ format |
| 37 | SECOND()
Retourne la seconde (0-59) |
38 | STR_TO_DATE()
Convertit une chaîne de caractères en une date |
| 39 | SUBDATE()
Lorsqu’il est invoqué avec trois arguments, un synonyme de DATE_SUB() |
| 40 | SUBTIME()
Soustraire des temps |
| 41 | SYSDATE()
Retourne l’heure à laquelle la fonction s’exécute |
| 42 | . TIME_FORMAT()
Formatage en temps |
| 43 | Temps_TO_SEC()
Retourne l’argument converti en secondes |
| 44 | TO_SEC()
Extrait la partie temps de l’expression passée |
45 | TIMEDIFF()
Soustraction du temps |
| 46 | TIMESTAMP()
Avec un seul argument, cette fonction renvoie l’expression de la date ou du temps. Avec deux arguments , la somme des arguments |
| 47 | TIMESTAMPADD()
Ajoute un intervalle à une expression de date/heure expression |
| 48 | TIMESTAMPDIFF()
Soustraire un intervalle d’une expression de date-temps |
| 49 | TO_DAYS()
Retourne l’argument date converti en jours |
| 50 | UNIX_TIMESTAMP()
Retourne un horodatage UNIX |
| 51 | UTC_DATE()
Retourne la date UTC actuelle |
| 52 | UTC_TIME()
Retourne l’heure UTC actuelle |
| 53 | UTC_TIMESTAMP()
Retourne la date et l’heure UTC courante |
| 54 | WEEK()
Retourne le numéro de la semaine |
| 55 | WEEKDAY()
Retourne l’indice du jour de la semaine . l’indice du jour de la semaine |
| 56 | WEEKOFYEAR()Retourne la semaine calendaire de la date (1-53) |
| 57 | YEAR()
Retourne l’année |
| 58 | YEARWEEK()
Retourne l’année et la semaine |
ADDDATE(date,INTERVALLE expr unité), ADDDATE(expr,jours)
Lorsqu’elle est invoquée avec la forme INTERVALLE du second argument, ADDDATE() est un synonyme de DATE_ADD(). La fonction connexe SUBDATE() est un synonyme de DATE_SUB(). Pour plus d’informations sur l’argument d’unité INTERVAL, voir la discussion sur DATE_ADD().
mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);+---------------------------------------------------------+| DATE_ADD('1998-01-02', INTERVAL 31 DAY) |+---------------------------------------------------------+| 1998-02-02 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);+---------------------------------------------------------+| ADDDATE('1998-01-02', INTERVAL 31 DAY) |+---------------------------------------------------------+| 1998-02-02 |+---------------------------------------------------------+1 row in set (0.00 sec)
Lorsqu’elle est invoquée avec la forme days du second argument, MySQL la traite comme un nombre entier de jours à ajouter à expr.
mysql> SELECT ADDDATE('1998-01-02', 31);+---------------------------------------------------------+| DATE_ADD('1998-01-02', INTERVAL 31 DAY) |+---------------------------------------------------------+| 1998-02-02 |+---------------------------------------------------------+1 row in set (0.00 sec)
ADDTIME(expr1,expr2)
ADDTIME() ajoute expr2 à expr1 et renvoie le résultat. L’expr1 est une expression de temps ou de date, tandis que l’expr2 est une expression de temps.
mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');+---------------------------------------------------------+| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |+---------------------------------------------------------+| 1998-01-02 01:01:01.000001 |+---------------------------------------------------------+1 row in set (0.00 sec)
CONVERT_TZ(dt,from_tz,to_tz)
Cette fonction convertit une valeur de date dt du fuseau horaire donné par from_tz au fuseau horaire donné par to_tz et renvoie la valeur résultante. Cette fonction renvoie NULL si les arguments ne sont pas valides.
mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');+---------------------------------------------------------+| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET') |+---------------------------------------------------------+| 2004-01-01 13:00:00 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');+---------------------------------------------------------+| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00') |+---------------------------------------------------------+| 2004-01-01 22:00:00 |+---------------------------------------------------------+1 row in set (0.00 sec)
CURDATE()
Retourne la date courante sous forme de valeur au format ‘AAAA-MM-JJ’ ou AAAAMMJJ, selon que la fonction est utilisée dans une chaîne de caractères ou dans un contexte numérique.
mysql> SELECT CURDATE();+---------------------------------------------------------+| CURDATE() |+---------------------------------------------------------+| 1997-12-15 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT CURDATE() + 0;+---------------------------------------------------------+| CURDATE() + 0 |+---------------------------------------------------------+| 19971215 |+---------------------------------------------------------+1 row in set (0.00 sec)
CURRENT_DATE et CURRENT_DATE()
CURRENT_DATE et CURRENT_DATE() sont des synonymes de CURDATE()
CURTIME()
Retourne l’heure courante sous forme de valeur au format ‘HH :MM:SS’ ou au format HHMMSS, selon que la fonction est utilisée dans une chaîne de caractères ou dans un contexte numérique. La valeur est exprimée dans le fuseau horaire actuel.
mysql> SELECT CURTIME();+---------------------------------------------------------+| CURTIME() |+---------------------------------------------------------+| 23:50:26 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT CURTIME() + 0;+---------------------------------------------------------+| CURTIME() + 0 |+---------------------------------------------------------+| 235026 |+---------------------------------------------------------+1 row in set (0.00 sec)
CURRENT_TIME et CURRENT_TIME()
CURRENT_TIME et CURRENT_TIME() sont des synonymes de CURTIME().
CURRENT_TIMESTAMP et CURRENT_TIMESTAMP()
CURRENT_TIMESTAMP et CURRENT_TIMESTAMP() sont des synonymes de NOW().
DATE(expr)
Extrait la partie date de l’expression date ou datetime expr.
mysql> SELECT DATE('2003-12-31 01:02:03');+---------------------------------------------------------+| DATE('2003-12-31 01:02:03') |+---------------------------------------------------------+| 2003-12-31 |+---------------------------------------------------------+1 row in set (0.00 sec)
DATEDIFF(expr1,expr2)
DATEDIFF() renvoie expr1 . expr2 exprimée comme une valeur en jours d’une date à l’autre. Les deux expr1 et expr2 sont des expressions de date ou de date et heure. Seules les parties date des valeurs sont utilisées dans le calcul.
mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');+---------------------------------------------------------+| DATEDIFF('1997-12-31 23:59:59','1997-12-30') |+---------------------------------------------------------+| 1 |+---------------------------------------------------------+1 row in set (0.00 sec)
DATE_ADD(date,INTERVALLE expr unité), DATE_SUB(date,INTERVALLE expr unité)
Ces fonctions effectuent une arithmétique de date. La date est une valeur DATETIME ou DATE spécifiant la date de début. L’expr est une expression spécifiant la valeur d’intervalle à ajouter ou à soustraire de la date de départ. L’expr est une chaîne de caractères ; elle peut commencer par un ‘-‘ pour les intervalles négatifs.
Une unité est un mot clé indiquant les unités dans lesquelles l’expression doit être interprétée.
Le mot clé INTERVAL et le spécificateur d’unité ne sont pas sensibles à la casse.
Le tableau suivant montre la forme attendue de l’argument expr pour chaque valeur d’unité.
| unité Valeur | Format expr attendu |
|---|---|
| MICROSECONDE | MICROSECONDE |
| SECONDE | SECONDE | MINUTE | MINUTES |
| Heure | Heures | JOURS | JOURS | WEEK | WEEKS | MONTH | MONTHS | Quarter | Quartiers | Années | Années |
| Seconde_MICROSECONDE | ‘SECONDES.MICROSECONDS’ | MINUTE_MICROSECOND | MINUTES.MICROSECONDS’ | MINUTE_SECOND | MINUTES:SECONDS’ | HOUR_MICROSECOND | HOURES.MICROSECONDS’ | HOUR_SECONDE | HOURS:MINUTES:SECONDES’ | Tr> | HOUR_MINUTE | ‘HEURES:MINUTES’ | JOUR_MICROSECONDE | JOURS.MICROSECONDES’ | DAY_SECOND | JOURS HEURES:MINUTES:SECONDES’ | DAY_MINUTE | JOURS HEURES :MINUTES’ | DAY_HOUR | ‘JOURS HEURES’ | YEAR_MONTH | ‘ANNÉES-MONTHS’ |
Les valeurs QUARTER et WEEK sont disponibles à partir de la version MySQL 5.0.0. version.
mysql> SELECT DATE_ADD('1997-12-31 23:59:59', -> INTERVAL '1:1' MINUTE_SECOND);+---------------------------------------------------------+| DATE_ADD('1997-12-31 23:59:59', INTERVAL... |+---------------------------------------------------------+| 1998-01-01 00:01:00 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);+---------------------------------------------------------+| DATE_ADD('1999-01-01', INTERVAL 1 HOUR) |+---------------------------------------------------------+| 1999-01-01 01:00:00 |+---------------------------------------------------------+1 row in set (0.00 sec)
DATE_FORMAT(date,format)
Cette commande formate la valeur de la date selon la chaîne de format.
Les spécificateurs suivants peuvent être utilisés dans la chaîne de format. Le caractère ‘%’ est requis avant les caractères de spécification de format.
| No de matricule. | Spécificateur & Description |
|---|---|
| 1 |
%a Nom abrégé du jour de semaine (dim..sam) |
| 2 |
%b Nom du mois abrégé (Jan..Dec) |
| 3 |
%c Mois, numérique (0…12) |
4 |
%D Jour du mois avec suffixe anglais (0e, 1er, 2e, 3e, .) |
5 |
%d Jour du mois, numérique (00….31) |
| 6 |
%e Jour du mois, numérique (0..31) |
| 7 |
%f Microsecondes (000000….999999) |
| 8 |
%H Heure (00..23) |
| 9 |
%h Heure (01..12) |
| 10 |
%I Heure (01..12) |
11 |
%i Minutes, numérique (00..59) |
| 12 |
%j Jour l’année (001..366) |
| 13 |
%k Heure (0..23) |
| 14 |
%l Heure (1..12) |
| 15 |
%M Nom du mois (janvier..décembre) |
16 |
%m Mois, numérique (00…12) |
| 17 |
%p AM ou PM |
18 |
%r Heure, 12 heures (hh :mm:ss suivi de AM ou PM) |
| 19 |
%S Secondes (00..59) |
| 20 |
%s Secondes (00…59) |
| 21 |
%T Heure, 24 heures (hh:mm:ss) |
| 22 |
%U Semaine (00..53), où le dimanche est le premier jour de la semaine |
| 23 |
%u Semaine (00..53), où le lundi est le premier jour de la semaine |
| 24 |
%V Semaine (01..53), où le dimanche est le premier jour de la semaine ; utilisé avec %X |
| 25 |
%v Semaine (01…53), où le lundi est le premier jour de la semaine ; utilisé avec %x |
| 26 |
%W Nom du jour de la semaine (dimanche..samedi) |
| 27 |
%w Jour de la semaine (0=dimanche.6=samedi) |
| 28 |
%X Année de la semaine où le dimanche est le premier jour de la semaine, numérique, quatre chiffres ; utilisé avec %V |
| 29 |
%x Année de la semaine, où le lundi est le premier jour de la semaine, numérique, quatre chiffres ; utilisé avec %v |
| 30 |
%Y Année, numérique, quatre chiffres |
| 31 |
%y Année, numérique (deux chiffres) |
| 32 |
%% Un littéral .%. caractère |
33 |
%x x, pour tout .x. non listé ci-dessus |
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');+---------------------------------------------------------+| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y') |+---------------------------------------------------------+| Saturday October 1997 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00' -> '%H %k %I %r %T %S %w');+---------------------------------------------------------+| DATE_FORMAT('1997-10-04 22:23:00....... |+---------------------------------------------------------+| 22 22 10 10:23:00 PM 22:23:00 00 6 |+---------------------------------------------------------+1 row in set (0.00 sec)
DATE_SUB(date,INTERVAL expr unité)
Cette fonction est similaire à la fonction DATE_ADD().
DAY(date)
Le DAY() est un synonyme de la fonction DAYOFMONTH().
DAYNAME(date)
Retourne le nom du jour de la semaine pour la date.
mysql> SELECT DAYNAME('1998-02-05');+---------------------------------------------------------+| DAYNAME('1998-02-05') |+---------------------------------------------------------+| Thursday |+---------------------------------------------------------+1 row in set (0.00 sec)
DAYOFMONTH(date)
Retourne le jour du mois pour la date, dans la plage 0 à 31.
mysql> SELECT DAYOFMONTH('1998-02-03');+---------------------------------------------------------+| DAYOFMONTH('1998-02-03') |+---------------------------------------------------------+| 3 |+---------------------------------------------------------+1 row in set (0.00 sec)
DAYOFWEEK(date)
Retourne l’indice de jour de semaine pour la date (1 = dimanche, 2 = lundi, ., 7 = samedi). Ces valeurs d’index correspondent à la norme ODBC.
mysql> SELECT DAYOFWEEK('1998-02-03');+---------------------------------------------------------+|DAYOFWEEK('1998-02-03') |+---------------------------------------------------------+| 3 |+---------------------------------------------------------+1 row in set (0.00 sec)
DAYOFYEAR(date)
Retourne le jour de l’année pour la date, dans la plage 1 à 366.
mysql> SELECT DAYOFYEAR('1998-02-03');+---------------------------------------------------------+| DAYOFYEAR('1998-02-03') |+---------------------------------------------------------+| 34 |+---------------------------------------------------------+1 row in set (0.00 sec)
EXTRACT(unité de la date)
La fonction EXTRACT() utilise les mêmes types de spécificateurs d’unité que DATE_ADD() ou DATE_SUB(), mais extrait des parties de la date plutôt que d’effectuer l’arithmétique de la date.
mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');+---------------------------------------------------------+| EXTRACT(YEAR FROM '1999-07-02') |+---------------------------------------------------------+| 1999 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');+---------------------------------------------------------+| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03') |+---------------------------------------------------------+| 199907 |+---------------------------------------------------------+1 row in set (0.00 sec)
FROM_DAYS(N)
Donné un nombre de jours N, renvoie une valeur DATE.
mysql> SELECT FROM_DAYS(729669);+---------------------------------------------------------+| FROM_DAYS(729669) |+---------------------------------------------------------+| 1997-10-07 |+---------------------------------------------------------+1 row in set (0.00 sec)
Note – Utilisez FROM_DAYS() avec prudence sur les anciennes dates. Elle n’est pas destinée à être utilisée avec des valeurs antérieures à l’avènement du calendrier grégorien (1582).
FROM_UNIXTIME(unix_timestamp,format)
Retourne une représentation de l’argument unix_timestamp sous la forme d’une valeur au format ‘YYYY-MM-DD HH:MM:SS ou YYYYMMDDHHMMSS, selon que la fonction est utilisée dans un contexte de chaîne ou dans un contexte numérique. La valeur est exprimée dans le fuseau horaire actuel. L’argument unix_timestamp est une valeur d’horodatage interne, qui est produite par la fonction UNIX_TIMESTAMP().
Si le format est donné, le résultat est formaté selon la chaîne de format, qui est utilisée de la même manière que celle listée dans l’entrée de la fonction DATE_FORMAT().
mysql> SELECT FROM_UNIXTIME(875996580);+---------------------------------------------------------+| FROM_UNIXTIME(875996580) |+---------------------------------------------------------+| 1997-10-04 22:23:00 |+---------------------------------------------------------+1 row in set (0.00 sec)
HOUR(time)
Retourne l’heure pour le temps. La plage de la valeur de retour est de 0 à 23 pour les valeurs d’heure du jour. Cependant, la plage des valeurs de l’heure est en réalité beaucoup plus large, de sorte que HOUR peut retourner des valeurs supérieures à 23.
mysql> SELECT HOUR('10:05:03');+---------------------------------------------------------+| HOUR('10:05:03') |+---------------------------------------------------------+| 10 |+---------------------------------------------------------+1 row in set (0.00 sec)
LAST_DAY(date)
Prend une valeur de date ou de datetime et retourne la valeur correspondante pour le dernier jour du mois. Renvoie NULL si l’argument est invalide.
mysql> SELECT LAST_DAY('2003-02-05');+---------------------------------------------------------+| LAST_DAY('2003-02-05') |+---------------------------------------------------------+| 2003-02-28 |+---------------------------------------------------------+1 row in set (0.00 sec)
LOCALTIME et LOCALTIME()
LOCALTIME et LOCALTIME() sont des synonymes de NOW().
LOCALTIMESTAMP et LOCALTIMESTAMP()
LOCALTIMESTAMP et LOCALTIMESTAMP() sont des synonymes de NOW().
MAKEDATE(year,dayofyear)
Retourne une date, étant donné les valeurs de l’année et du jour de l’année. La valeur du jour de l’année doit être supérieure à 0 ou le résultat sera NULL.
mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);+---------------------------------------------------------+| MAKEDATE(2001,31), MAKEDATE(2001,32) |+---------------------------------------------------------+| '2001-01-31', '2001-02-01' |+---------------------------------------------------------+1 row in set (0.00 sec)
MAKETIME(hour,minute,second)
Retourne une valeur de temps calculée à partir des arguments heure, minute et seconde.
mysql> SELECT MAKETIME(12,15,30);+---------------------------------------------------------+| MAKETIME(12,15,30) |+---------------------------------------------------------+| '12:15:30' |+---------------------------------------------------------+1 row in set (0.00 sec)
MICROSECOND(expr)
Retourne les microsecondes de l’expression de l’heure ou de la date (expr) comme un nombre dans la plage de 0 à 999999.
mysql> SELECT MICROSECOND('12:00:00.123456');+---------------------------------------------------------+| MICROSECOND('12:00:00.123456') |+---------------------------------------------------------+| 123456 |+---------------------------------------------------------+1 row in set (0.00 sec)
MINUTE(time)
Retourne la minute de l’heure, dans la plage de 0 à 59.
mysql> SELECT MINUTE('98-02-03 10:05:03');+---------------------------------------------------------+| MINUTE('98-02-03 10:05:03') |+---------------------------------------------------------+| 5 |+---------------------------------------------------------+1 row in set (0.00 sec)
MONTH(date)
Retourne le mois pour la date, dans la plage de 0 à 12.
mysql> SELECT MONTH('1998-02-03')+---------------------------------------------------------+| MONTH('1998-02-03') |+---------------------------------------------------------+| 2 |+---------------------------------------------------------+1 row in set (0.00 sec)
MONTHNAME(date)
Retourne le nom complet du mois pour une date.
mysql> SELECT MONTHNAME('1998-02-05');+---------------------------------------------------------+| MONTHNAME('1998-02-05') |+---------------------------------------------------------+| February |+---------------------------------------------------------+1 row in set (0.00 sec)
NOW()
Retourne la date et l’heure actuelles sous forme de valeur au format ‘YYYY-MM-DD HH:MM:SS’ ou YYYYMMDDHHMMSS, selon que la fonction est utilisée dans un contexte de chaîne ou numérique. Cette valeur est exprimée dans le fuseau horaire actuel.
mysql> SELECT NOW();+---------------------------------------------------------+| NOW() |+---------------------------------------------------------+| 1997-12-15 23:50:26 |+---------------------------------------------------------+1 row in set (0.00 sec)
PERIOD_ADD(P,N)
Ajoute N mois à une période P (au format AAMM ou AAMM). Retourne une valeur au format YYYYMM. Notez que l’argument période P n’est pas une valeur de date.
mysql> SELECT PERIOD_ADD(9801,2);+---------------------------------------------------------+| PERIOD_ADD(9801,2) |+---------------------------------------------------------+| 199803 |+---------------------------------------------------------+1 row in set (0.00 sec)
PERIOD_DIFF(P1,P2)
Retourne le nombre de mois entre les périodes P1 et P2. Ces périodes P1 et P2 doivent être au format YYMM ou YYYYMM. Notez que les arguments de période P1 et P2 ne sont pas des valeurs de date.
mysql> SELECT PERIOD_DIFF(9802,199703);+---------------------------------------------------------+| PERIOD_DIFF(9802,199703) |+---------------------------------------------------------+| 11 |+---------------------------------------------------------+1 row in set (0.00 sec)
QUARTER(date)
Retourne le trimestre de l’année pour la date, dans la plage 1 à 4.
mysql> SELECT QUARTER('98-04-01');+---------------------------------------------------------+| QUARTER('98-04-01') |+---------------------------------------------------------+| 2 |+---------------------------------------------------------+1 row in set (0.00 sec)
SECONDE(heure)
Retourne la seconde pour l’heure, dans la plage de 0 à 59.
mysql> SELECT SECOND('10:05:03');+---------------------------------------------------------+| SECOND('10:05:03') |+---------------------------------------------------------+| 3 |+---------------------------------------------------------+1 row in set (0.00 sec)
SEC_TO_TIME(seconds)
Retourne l’argument secondes, converti en heures, minutes et secondes, sous la forme d’une valeur au format ‘HH:MM:SS’ ou HHMMSS, selon que la fonction est utilisée dans un contexte de chaîne ou numérique.
mysql> SELECT SEC_TO_TIME(2378);+---------------------------------------------------------+| SEC_TO_TIME(2378) |+---------------------------------------------------------+| 00:39:38 |+---------------------------------------------------------+1 row in set (0.00 sec)
STR_TO_DATE(str,format)
C’est l’inverse de la fonction DATE_FORMAT(). Elle prend une chaîne de caractères str et une chaîne de caractères format. La fonction STR_TO_DATE() renvoie une valeur DATETIME si la chaîne de format contient les deux parties date et heure. Sinon, elle renvoie une valeur DATE ou TIME si la chaîne ne contient que des parties de date ou d’heure.
mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');+---------------------------------------------------------+| STR_TO_DATE('04/31/2004', '%m/%d/%Y') |+---------------------------------------------------------+| 2004-04-31 |+---------------------------------------------------------+1 row in set (0.00 sec)
SUBDATE(date,unité INTERVALLE expr) et SUBDATE(expr,jours)
Lorsqu’elle est invoquée avec la forme INTERVALLE du deuxième argument, SUBDATE() est un synonyme de DATE_SUB(). Pour plus d’informations sur l’argument d’unité INTERVAL, voir la discussion sur DATE_ADD().
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);+---------------------------------------------------------+| DATE_SUB('1998-01-02', INTERVAL 31 DAY) |+---------------------------------------------------------+| 1997-12-02 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);+---------------------------------------------------------+| SUBDATE('1998-01-02', INTERVAL 31 DAY) |+---------------------------------------------------------+| 1997-12-02 |+---------------------------------------------------------+1 row in set (0.00 sec)
SUBTIME(expr1,expr2)
La fonction SUBTIME() renvoie expr1 . expr2 exprimée comme une valeur au même format que expr1. La valeur expr1 est une expression de temps ou de date, tandis que la valeur expr2 est une expression de temps.
mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999', -> '1 1:1:1.000002');+---------------------------------------------------------+| SUBTIME('1997-12-31 23:59:59.999999'... |+---------------------------------------------------------+| 1997-12-30 22:58:58.999997 |+---------------------------------------------------------+1 row in set (0.00 sec)
SYSDATE()
Retourne la date et l’heure actuelles sous la forme d’une valeur au format ‘YYYY-MM-DD HH:MM:SS’ ou YYYYMMDDHHMMSS, selon que la fonction est utilisée dans une chaîne de caractères ou dans un contexte numérique.
mysql> SELECT SYSDATE();+---------------------------------------------------------+| SYSDATE() |+---------------------------------------------------------+| 2006-04-12 13:47:44 |+---------------------------------------------------------+1 row in set (0.00 sec)
TIME(expr)
Extrait la partie temps de l’expression de temps ou de date expr et la renvoie sous forme de chaîne de caractères.
mysql> SELECT TIME('2003-12-31 01:02:03');+---------------------------------------------------------+| TIME('2003-12-31 01:02:03') |+---------------------------------------------------------+| 01:02:03 |+---------------------------------------------------------+1 row in set (0.00 sec)
TIMEDIFF(expr1,expr2)
La fonction TIMEDIFF() renvoie expr1 . expr2 exprimée sous forme de valeur temporelle. Ces valeurs expr1 et expr2 sont des expressions de temps ou de date et heure, mais les deux doivent être du même type.
mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001', -> '1997-12-30 01:01:01.000002');+---------------------------------------------------------+| TIMEDIFF('1997-12-31 23:59:59.000001'..... |+---------------------------------------------------------+| 46:58:57.999999 |+---------------------------------------------------------+1 row in set (0.00 sec)
TIMESTAMP(expr), TIMESTAMP(expr1,expr2)
Avec un seul argument, cette fonction renvoie l’expression de date ou de temps expr comme une valeur de temps. Avec deux arguments, elle ajoute l’expression temporelle expr2 à l’expression de date ou de datetime expr1 et renvoie le résultat sous forme de valeur de datetime.
mysql> SELECT TIMESTAMP('2003-12-31');+---------------------------------------------------------+| TIMESTAMP('2003-12-31') |+---------------------------------------------------------+| 2003-12-31 00:00:00 |+---------------------------------------------------------+1 row in set (0.00 sec)
TIMESTAMPADD(unité,intervalle,datetime_expr)
Cette fonction ajoute l’expression entière intervalle à l’expression de date ou de datetime datetime_expr. L’unité de l’intervalle est donnée par l’argument unité, qui doit être l’une des valeurs suivantes –
- FRAC_SECOND
- SECOND, MINUTE
- HOUR, DAY
- WEEK
- MONTH
- QUARTER ou
- YEAR
La valeur de l’unité peut être spécifiée à l’aide de l’un des mots-clés comme indiqué ou avec un préfixe de SQL_TSI_.
Par exemple, DAY et SQL_TSI_DAY sont tous deux légaux.
mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');+---------------------------------------------------------+| TIMESTAMPADD(MINUTE,1,'2003-01-02') |+---------------------------------------------------------+| 2003-01-02 00:01:00 |+---------------------------------------------------------+1 row in set (0.00 sec)
TIMESTAMPDIFF(unité,datetime_expr1,datetime_expr2)
Retourne la différence entière entre les expressions date ou datetime datetime_expr1 et datetime_expr2. L’unité du résultat est donnée par l’argument unité. Les valeurs légales pour l’unité sont les mêmes que celles énumérées dans la description de la fonction TIMESTAMPADD().
mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');+---------------------------------------------------------+| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01') |+---------------------------------------------------------+| 3 |+---------------------------------------------------------+1 row in set (0.00 sec)
TIME_FORMAT(time,format)
Cette fonction est utilisée comme la fonction DATE_FORMAT(), mais la chaîne de format peut contenir des spécificateurs de format uniquement pour les heures, les minutes et les secondes.
Si la valeur de l’heure contient une partie d’heure supérieure à 23, les spécificateurs de format d’heure %H et %k produisent une valeur supérieure à la plage habituelle de 0 à 23. Les autres spécificateurs de format d’heure produisent la valeur de l’heure modulo 12.
mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');+---------------------------------------------------------+| TIME_FORMAT('100:00:00', '%H %k %h %I %l') |+---------------------------------------------------------+| 100 100 04 04 4 |+---------------------------------------------------------+1 row in set (0.00 sec)
TIME_TO_SEC(time)
Retourne l’argument temps converti en secondes.
mysql> SELECT TIME_TO_SEC('22:23:00');+---------------------------------------------------------+| TIME_TO_SEC('22:23:00') |+---------------------------------------------------------+| 80580 |+---------------------------------------------------------+1 row in set (0.00 sec)
TO_DAYS(date)
Donnée une date, renvoie un nombre de jours (le nombre de jours depuis l’année 0).
mysql> SELECT TO_DAYS(950501);+---------------------------------------------------------+| TO_DAYS(950501) |+---------------------------------------------------------+| 728779 |+---------------------------------------------------------+1 row in set (0.00 sec)
UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)
Si elle est appelée sans argument, cette fonction renvoie un timestamp Unix (secondes depuis ‘1970-01-01 00:00:00’ UTC) sous la forme d’un entier non signé. Si UNIX_TIMESTAMP() est appelée avec un argument date, elle renvoie la valeur de l’argument sous forme de secondes depuis ‘1970-01-01 00:00:00’ UTC. date peut être une chaîne DATE, une chaîne DATETIME, un TIMESTAMP ou un nombre au format AAMMJJ ou AAAAMMJJ.
mysql> SELECT UNIX_TIMESTAMP();+---------------------------------------------------------+| UNIX_TIMESTAMP() |+---------------------------------------------------------+| 882226357 |+---------------------------------------------------------+1 row in set (0.00 sec)mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');+---------------------------------------------------------+| UNIX_TIMESTAMP('1997-10-04 22:23:00') |+---------------------------------------------------------+| 875996580 |+---------------------------------------------------------+1 row in set (0.00 sec)
UTC_DATE, UTC_DATE()
Retourne la date UTC actuelle sous la forme d’une valeur au format ‘YYYY-MM-DD’ ou YYYYMMDD, selon que la fonction est utilisée dans un contexte de chaîne ou numérique.
mysql> SELECT UTC_DATE(), UTC_DATE() + 0;+---------------------------------------------------------+| UTC_DATE(), UTC_DATE() + 0 |+---------------------------------------------------------+| 2003-08-14, 20030814 |+---------------------------------------------------------+1 row in set (0.00 sec)
UTC_TIME, UTC_TIME()
Retourne l’heure UTC actuelle sous la forme d’une valeur au format ‘HH:MM:SS’ ou HHMMSS, selon que la fonction est utilisée dans un contexte de chaîne ou numérique.
mysql> SELECT UTC_TIME(), UTC_TIME() + 0;+---------------------------------------------------------+| UTC_TIME(), UTC_TIME() + 0 |+---------------------------------------------------------+| 18:07:53, 180753 |+---------------------------------------------------------+1 row in set (0.00 sec)
UTC_TIMESTAMP, UTC_TIMESTAMP()
Retourne la date et l’heure UTC actuelles sous la forme d’une valeur au format ‘YYYY-MM-DD HH:MM:SS’ ou au format YYYYMMDDHHMMSS, selon que la fonction est utilisée dans un contexte de chaîne ou numérique.
mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;+---------------------------------------------------------+| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0 |+---------------------------------------------------------+| 2003-08-14 18:08:04, 20030814180804 |+---------------------------------------------------------+1 row in set (0.00 sec)
WEEK(date)
Cette fonction renvoie le numéro de semaine pour la date. La forme à deux arguments de WEEK() vous permet de spécifier si la semaine commence un dimanche ou un lundi et si la valeur de retour doit être comprise entre 0 et 53 ou entre 1 et 53. Si l’argument mode est omis, la valeur de la variable système default_week_format est utilisée
| Mode | Premier jour de la semaine | Range | La semaine 1 est la première semaine. |
|---|---|---|---|
| 0 | Dimanche | 0-53 | avec un dimanche dans cette année |
| 1 | Lundi | 0-…53 | avec plus de 3 jours dans cette année |
| 2 | Dimanche | 1-.53 | avec un dimanche dans cette année |
| 3 | Lundi | 1-53 | avec plus de 3 jours cette année |
| 4 | Dimanche | 0-53 | avec plus de 3 jours cette année |
| 5 | Lundi | 0-53 | avec un lundi dans cette année | 6 | Dimanche | 1-…53 | avec plus de 3 jours cette année |
| 7 | Lundi | 1-53 | avec un lundi dans cette année |
mysql> SELECT WEEK('1998-02-20');+---------------------------------------------------------+| WEEK('1998-02-20') |+---------------------------------------------------------+| 7 |+---------------------------------------------------------+1 row in set (0.00 sec)
WEEKDAY(date)
Retourne l’indice de jour de semaine pour la date (0 = lundi, 1 = mardi, . 6 = dimanche).
mysql> SELECT WEEKDAY('1998-02-03 22:23:00');+---------------------------------------------------------+| WEEKDAY('1998-02-03 22:23:00') |+---------------------------------------------------------+| 1 |+---------------------------------------------------------+1 row in set (0.00 sec)
WEEKOFYEAR(date)
Retourne la semaine calendaire de la date sous la forme d’un nombre compris entre 1 et 53. WEEKOFYEAR() est une fonction de compatibilité qui est équivalente à WEEK(date,3).
mysql> SELECT WEEKOFYEAR('1998-02-20');+---------------------------------------------------------+| WEEKOFYEAR('1998-02-20') |+---------------------------------------------------------+| 8 |+---------------------------------------------------------+1 row in set (0.00 sec)
YEAR(date)
Retourne l’année de la date, dans la plage 1000 à 9999, ou 0 pour la date .zéro. date.
mysql> SELECT YEAR('98-02-03');+---------------------------------------------------------+| YEAR('98-02-03') |+---------------------------------------------------------+| 1998 |+---------------------------------------------------------+1 row in set (0.00 sec)
YEARWEEK(date), YEARWEEK(date,mode)
Retourne l’année et la semaine pour une date. L’argument mode fonctionne exactement comme l’argument mode de la fonction WEEK(). L’année dans le résultat peut être différente de l’année dans l’argument date pour la première et la dernière semaine de l’année.
mysql> SELECT YEARWEEK('1987-01-01');+---------------------------------------------------------+| YEAR('98-02-03')YEARWEEK('1987-01-01') |+---------------------------------------------------------+| 198653 |+---------------------------------------------------------+1 row in set (0.00 sec)
Note – Le numéro de semaine est différent de ce que la fonction WEEK() renverrait (0) pour les arguments optionnels 0 ou 1, car WEEK() renvoie alors la semaine dans le contexte de l’année donnée.
.