Manuel de référence MySQL 5.0

12-1-1. Précédence des opérateurs▲

:=
||, OR, XOR
&&, AND
BETWEEN, CASE, WHEN, THEN, ELSE
=, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
|
&
<<, >>
-, +
*, /, DIV, %, MOD
^
- (unary minus), ~ (unary bit inversion)
NOT, !
BINARY, COLLATE

12-1-2. Parenthèses▲

12-1-3. Opérateurs de comparaison▲

mysql> SELECT "a" ="A \n";
        -> 1

mysql> SELECT 1 > '6x';
         -> 0
mysql> SELECT 7 > '6x';
         -> 1
mysql> SELECT 0 > 'x6';
         -> 0
mysql> SELECT 0 = 'x6';
         -> 1

12-1-4. Opérateurs logiques▲

• IFNULL(expr1,expr2)

  Si l'argument expr1 n'est pas NULL, la fonction IFNULL() retournera l'argument expr1, sinon elle retournera l'argument expr2. La fonction IFNULL() retourne une valeur numérique ou une chaîne de caractères, suivant le contexte d'utilisation :

   

  Sélectionnez

  mysql> SELECT IFNULL(1,0);
          -> 1
  mysql> SELECT IFNULL(NULL,10);
          -> 10
  mysql> SELECT IFNULL(1/0,10);
          -> 10
  mysql> SELECT IFNULL(1/0,'oui');
          -> 'oui'

  En version 4.0.6 et plus récentes, le résultat par défaut de IFNULL(expr1,expr2) est le plus « général » des deux expressions, dans l'ordre de type STRING, REAL ou INTEGER. La différence avec les anciennes versions de MySQL ne sera notable que si vous créez une table basée sur des expressions, ou si MySQL stocke en interne des valeurs issues de IFNULL() dans une table temporaire.

   

  Sélectionnez

  CREATE TABLE foo SELECT IFNULL(1,"test") as test;

  En MySQL 4.0.6, le type de la colonne test est CHAR(4) tandis que dans les versions plus anciennes, vous auriez obtenu un BIGINT.

• NULLIF(expr1,expr2)

  Si l'expression expr1 = expr2 est vraie, la fonction retourne NULL sinon elle retourne expr1. Cela revient à faire CASE WHEN x = y THEN NULL ELSE x END :

   

  Sélectionnez

  mysql> SELECT NULLIF(1,1);
          -> NULL
  mysql> SELECT NULLIF(1,2);
          -> 1

  Notez que l'argument expr1 est évalué deux fois dans MySQL si les arguments sont égaux.

• IF(expr1,expr2,expr3)

  Si l'argument expr1 vaut TRUE (expr1 <> 0 et expr1 <> NULL) alors la fonction IF() retourne l'argument expr2, sinon, elle retourne l'argument expr3. La fonction IF() retourne une valeur numérique ou une chaîne de caractères, suivant le contexte d'utilisation :

   

  Sélectionnez

  mysql> SELECT IF(1>2,2,3);
          -> 3
  mysql> SELECT IF(1<2,'oui','non');
          -> 'oui'
  mysql> SELECT IF(STRCMP('test','test1'),'non','oui');
          -> 'non'

  Si l'argument expr2 ou expr3 est explicitement NULL alors le type du résultat de la fonction IF() est le type de la colonne non NULL. (Ce comportement est nouveau dans MySQL 4.0.3.)

  L'argument expr1 est évalué comme un entier, cela signifie que si vous testez un nombre à virgule flottante ou une chaîne de caractères, vous devez utiliser une opération de comparaison :

   

  Sélectionnez

  mysql> SELECT IF(0.1,1,0);
          -> 0
  mysql> SELECT IF(0.1<>0,1,0);
          -> 1

  Dans le premier exemple ci-dessus, IF(0.1) retourne 0 parce que 0.1 est converti en une chaîne de caractères, ce qui revient à tester IF(0). Ce n'est certainement pas ce que vous désiriez. Dans le second exemple, la comparaison teste si le nombre à virgule flottante est différent de zéro. Le résultat de cette comparaison sera un entier.

  Le type de la fonction IF() (ce qui peut être important s'il est stocké dans une table temporaire) est calculé, dans la Version 3.23 de MySQL, comme suit :

  Expression	Valeur retournée
  expr2 ou expr3 retourne une chaîne	chaîne
  expr2 ou expr3 retourne un nombre à virgule	nombre à virgule
  expr2 ou expr3 retourne un entier	entier

  Si expr2 et expr3 sont des chaînes de caractères, alors le résultat est insensible à la casse si les deux chaînes de caractères sont insensibles à la casse. (À partir de la version 3.23.51 de MySQL)

• CASE valeur WHEN [compare-value] THEN résultat [WHEN [compare-value] THEN résultat ...] [ELSE résultat] END, CASE WHEN [condition] THEN résultat [WHEN [condition] THEN résultat ...] [ELSE résultat] END

  La première version retourne résultat si valeur=compare-value. La seconde version retourne le résultat de la première condition qui se réalise. Si aucune des conditions n'est réalisée, alors le résultat de la clause ELSE est retourné. S'il n'y a pas de clause ELSE alors NULL est retourné :

   

  Sélectionnez

  mysql> SELECT CASE 1 WHEN 1 THEN "un"
             WHEN 2 THEN "deux" ELSE "plus" END;
         -> "un"
  mysql> SELECT CASE WHEN 1>0 THEN "vrai" ELSE "faux" END;
         -> "vrai"
  mysql> SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END;
         -> NULL

Le type de la valeur retournée (INTEGER, DOUBLE ou STRING) est de même type que la première valeur retournée (l'expression après le premier THEN).

Les fonctions qui traitent les chaînes de caractères retournent NULL si la longueur du résultat finit par dépasser la taille maximale du paramètre max_allowed_packet, défini dans la configuration du serveur. Voir Section 7.5.2, « Réglage des paramètres du serveur »7.5.2. Réglage des paramètres du serveur.

Pour les fonctions qui opèrent sur des positions à l'intérieur d'une chaîne, la position initiale est 0.

• ASCII(str)

  Retourne le code ASCII du premier caractère de la chaîne de caractères str. Retourne 0 si la chaîne de caractères str est vide. Retourne NULL si la chaîne de caractères str est NULL. ASCII() fonctionne avec des valeurs numériques entre 0 et 255.

   

  Sélectionnez

  mysql> SELECT ASCII('2');
          -> 50
  mysql> SELECT ASCII(2);
          -> 50
  mysql> SELECT ASCII('dx');
          -> 100

  Voir aussi la fonction ORD().

• BIN(N)

  Retourne une chaîne de caractères représentant la valeur binaire de l'argument N, où l'argument N est un nombre de type BIGINT. Cette fonction est un équivalent de CONV(N,10,2). Retourne NULL si l'argument N est NULL.

   

  Sélectionnez

  mysql> SELECT BIN(12);
          -> '1100'

• BIT_LENGTH(str)

  Retourne le nombre de bits de la chaîne de caractères str.

   

  Sélectionnez

  mysql> SELECT BIT_LENGTH('text');
          -> 32

  BIT_LENGTH() a été ajouté en MySQL 4.0.2.

• CHAR(N,...)

  La fonction CHAR() interprète les arguments comme des entiers et retourne une chaîne de caractères, constituée des caractères, identifiés par leur code ASCII. Les valeurs NULL sont ignorées :

   

  Sélectionnez

  mysql> SELECT CHAR(77,121,83,81,'76');
          -> 'MySQL'
  mysql> SELECT CHAR(77,77.3,'77.3');
          -> 'MMM'

• CHAR_LENGTH(str)

  Retourne le nombre de caractères de la chaîne str. Un caractère multioctet compte comme un seul caractère. Cela signifie que pour une chaîne contenant 5 caractères de 2 octets, LENGTH() retournera 10, alors que CHAR_LENGTH() retournera 5.

• CHARACTER_LENGTH(str)

  CHARACTER_LENGTH() est un synonyme de CHAR_LENGTH().

• COMPRESS(string_to_compress)

  Compresse une chaîne. Cette fonction requiert la présence de la bibliothèque zlib. Sinon, la valeur retournée sera toujours NULL.

   

  Sélectionnez

  mysql> SELECT LENGTH(COMPRESS(REPEAT('a',1000)));
          -> 21
  mysql> SELECT LENGTH(COMPRESS(''));
          -> 0
  mysql> SELECT LENGTH(COMPRESS('a'));
          -> 13
  mysql> SELECT LENGTH(COMPRESS(REPEAT('a',16)));
          -> 15

  La chaîne compressée est stockée de la manière suivante.

  • Les chaînes vides sont stockées comme des chaînes vides.

  • Les chaînes non vides sont stockées avec 4 octets de plus, indiquant la taille de la chaîne non compressée, suivie de la chaîne compressée. Si la chaîne se termine avec des espaces, un point supplémentaire '.' est ajouté, pour éviter que les espaces terminaux soient supprimés de la chaîne. N'utilisez pas les types CHAR ou VARCHAR pour stocker des chaînes compressées. Il est mieux d'utiliser un type BLOB.

  COMPRESS() a été ajouté en MySQL 4.1.1.

• CONCAT(str1,str2,...)

  Retourne une chaîne représentant la concaténation des arguments. Retourne NULL si un des arguments est NULL. Cette fonction peut prendre plus de 2 arguments. Si un argument est un nombre, il sera converti en son équivalent sous forme de chaîne de caractères :

   

  Sélectionnez

  mysql> SELECT CONCAT('My', 'S', 'QL');
          -> 'MySQL'
  mysql> SELECT CONCAT('My', NULL, 'QL');
          -> NULL
  mysql> SELECT CONCAT(14.3);
          -> '14.3'

• CONCAT_WS(separator, str1, str2,...)

  La fonction CONCAT_WS() signifie CONCAT With Separator, c'est-à-dire « concaténation avec séparateur ». Le premier argument est le séparateur utilisé pour le reste des arguments. Le séparateur peut être une chaîne de caractères, tout comme le reste des arguments. Si le séparateur est NULL, le résultat sera NULL. Cette fonction ignorera tous les arguments de valeur NULL et vides, hormis le séparateur. Le séparateur sera ajouté entre tous les arguments à concaténer :

   

  Sélectionnez

  mysql> SELECT CONCAT_WS(",","Premier nom","Deuxième nom","Dernier nom");
         -> 'Premier nom,Deuxième nom,Dernier nom'
  mysql> SELECT CONCAT_WS(",","Premier nom",NULL,"Dernier nom");
         -> 'Premier nom,Dernier nom'

• CONV(N,from_base,to_base)

  Convertit des nombres entre différentes bases. Retourne une chaîne de caractères représentant le nombre N, converti de la base from_base vers la base to_base. La fonction retourne NULL si un des arguments est NULL. L'argument N est interprété comme un entier, mais peut être spécifié comme un entier ou une chaîne de caractères. Le minimum pour la base est 2 et son maximum est 36. Si to_base est un nombre négatif, N sera considéré comme un nombre signé. Dans le cas contraire, N sera traité comme un nombre non signé. La fonction CONV travaille avec une précision de 64 bits :

   

  Sélectionnez

  mysql> SELECT CONV("a",16,2);
          -> '1010'
  mysql> SELECT CONV("6E",18,8);
          -> '172'
  mysql> SELECT CONV(-17,10,-18);
          -> '-H'
  mysql> SELECT CONV(10+"10"+'10'+0xa,10,10);
          -> '40'

• ELT(N,str1,str2,str3,...)

  Retourne str1 si N = 1, str2 si N = 2, et ainsi de suite. Retourne NULL si N est plus petit que 1 ou plus grand que le nombre d'arguments. La fonction ELT() est un complément de la fonction FIELD() :

   

  Sélectionnez

  mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
          -> 'ej'
  mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
          -> 'foo'

• EXPORT_SET(bits,on,off,[séparateur,[nombre_de_bits]])

  Retourne une chaîne dont tous les bits à 1 dans « bit » sont représentés par la chaîne « on », et dont tous les bits à 0 sont représentés par la chaîne « off ». Chaque chaîne est séparée par 'séparateur' (par défaut, une virgule '','') et seul « nombre_de_bits » (par défaut, 64) « bits » est utilisé :

   

  Sélectionnez

  mysql> SELECT EXPORT_SET(5,'Y','N',',',4)
          -> Y,N,Y,N

• FIELD(str,str1,str2,str3,...)

  Retourne l'index de la chaîne str dans la liste str1, str2, str3, .... Retourne 0 si str n'est pas trouvé. La fonction FIELD() est un complément de la fonction ELT() :

   

  Sélectionnez

  mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
          -> 2
  mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
          -> 0

• FIND_IN_SET(str,strlist)

  Retourne une valeur de 1 à N si la chaîne str se trouve dans la liste strlist constituée de N chaînes. Une liste de chaînes est une chaîne composée de sous-chaînes séparées par une virgule ','. Si le premier argument est une chaîne constante et le second, une colonne de type SET, la fonction FIND_IN_SET() est optimisée pour utiliser une recherche binaire très rapide. Retourne 0 si str n'est pas trouvé dans la liste strlist ou si la liste strlist est une chaîne vide. Retourne NULL si l'un des arguments est NULL. Cette fonction ne fonctionne pas correctement si le premier argument contient une virgule ',' :

   

  Sélectionnez

  mysql> SELECT FIND_IN_SET('b','a,b,c,d');
          -> 2

• HEX(N_or_S)

  Si l'argument N_OR_S est un nombre, cette fonction retournera une chaîne de caractères représentant la valeur hexadécimale de l'argument N, où l'argument N est de type BIGINT. Cette fonction est un équivalent de CONV(N,10,16).

  Si N_OR_S est une chaîne de caractères, cette fonction retournera une chaîne de caractères hexadécimale de N_OR_S où chaque caractère de N_OR_S est converti en 2 chiffres hexadécimaux. C'est l'inverse de la chaîne 0xff.

   

  Sélectionnez

  mysql> SELECT HEX(255);
          -> 'FF'
  mysql> SELECT HEX("abc");
          -> 616263
  mysql> SELECT 0x616263;
          -> "abc"

• 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 caractères, par la chaîne newstr :

   

  Sélectionnez

  mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
          -> 'QuWhattic'

  Cette fonction gère les caractères multioctets.

• INSTR(str,substr)

  Retourne la position de la première occurrence de la chaîne substr dans la chaîne de caractères str. Cette fonction est exactement la même que la fonction LOCATE(), à la différence que ces arguments sont inversés :

   

  Sélectionnez

  mysql> SELECT INSTR('foobarbar', 'bar');
          -> 4
  mysql> SELECT INSTR('xbar', 'foobar');
          -> 0

  Cette fonction gère les caractères multioctets. Dans la version 3.23 de MySQL, cette fonction est sensible à la casse, alors que dans la version 4.0 de MySQL, cette fonction sera sensible à la casse si l'argument est une chaîne de caractères binaire.

• LCASE(str)

  LCASE() est un synonyme de LOWER().

• LEFT(str,len)

  Retourne les len caractères les plus à gauche de la chaîne de caractères str :

   

  Sélectionnez

  mysql> SELECT LEFT('foobarbar', 5);
          -> 'fooba'

  Cette fonction gère les caractères multioctets.

• LENGTH(str)

  Retourne la taille de la chaîne str, mesurée en octets. Un caractère multioctet compte comme un seul caractère. Cela signifie que pour une chaîne contenant 5 caractères de 2 octets, LENGTH() retournera 10, alors que CHAR_LENGTH() retournera 5.

   

  Sélectionnez

  mysql> SELECT LENGTH('text');
          -> 4

• LOAD_FILE(file_name)

  Lit le fichier file_name et retourne son contenu sous la forme d'une chaîne de caractères. Le fichier doit se trouver sur le serveur qui exécute MySQL, vous devez spécifier le chemin absolu du fichier et vous devez avoir les droits en lecture sur celui-ci. Le fichier doit pouvoir être lisible par tous et doit être plus petit que max_allowed_packet.

  Si ce fichier n'existe pas ou ne peut pas être lu pour différentes raisons, la fonction retourne NULL :

   

  Sélectionnez

  mysql> UPDATE tbl_name
             SET blob_column=LOAD_FILE("/tmp/picture")
             WHERE id=1;

  Si vous n'utilisez pas la version 3.23 de MySQL, vous devez lire le fichier depuis votre application et créer ainsi votre requête INSERT vous-même, pour mettre à jour la base de données avec le contenu de ce fichier. Une des possibilités pour réaliser ceci, si vous utilisez la bibliothèque MySQL++, peut être trouvée à http://www.mysql.com/documentation/mysql++/mysql++-examples.html.

• LOCATE(substr,str), LOCATE(substr,str,pos)

  Retourne la position de la première occurrence de la chaîne substr dans la chaîne de caractères str. Retourne 0 si substr ne se trouve pas dans la chaîne de caractères str :

   

  Sélectionnez

  mysql> SELECT LOCATE('bar', 'foobarbar');
          -> 4
  mysql> SELECT LOCATE('xbar', 'foobar');
          -> 0
  mysql> SELECT LOCATE('bar', 'foobarbar',5);
          -> 7

  Cette fonction gère les caractères multioctets. Dans la version 3.23 de MySQL, cette fonction est sensible à la casse, alors que dans la version 4.0 de MySQL, cette fonction sera sensible à la casse si l'argument est une chaîne de caractères binaire.

• LOWER(str)

  Retourne la chaîne str avec tous les caractères en minuscules, en fonction du jeu de caractères courant (par défaut, c'est le jeu ISO-8859-1 Latin1) :

   

  Sélectionnez

  mysql> SELECT LOWER('QUADRATIQUE');
          -> 'quadratique'

  Cette fonction gère les caractères multioctets.

• LPAD(str,len,padstr)

  Retourne la chaîne de caractères str, complétée à gauche par la chaîne de caractères padstr jusqu'à ce que la chaîne de caractères str atteigne len caractères de long. Si la chaîne de caractères str est plus longue que len caractères, elle sera raccourcie à len caractères.

   

  Sélectionnez

  mysql> SELECT LPAD('hi',4,'??');
          -> '??hi'

• LTRIM(str)

  Retourne la chaîne de caractères str sans les espaces initiaux :

   

  Sélectionnez

  mysql> SELECT LTRIM('  barbar');
          -> 'barbar'

• MAKE_SET(bits,str1,str2,...)

  Retourne une liste (une chaîne contenant des sous-chaînes séparées par une virgule ',') constituée de chaînes qui ont le bit correspondant dans la liste bits. str1 correspond au bit 0, str2 au bit 1, etc. Les chaînes NULL dans les listes str1, str2, ... sont ignorées :

   

  Sélectionnez

  mysql> SELECT MAKE_SET(1,'a','b','c');
          -> 'a'
  mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
          -> 'hello,world'
  mysql> SELECT MAKE_SET(0,'a','b','c');
          -> ''

• MID(str,pos,len)

  MID(str,pos,len) est un synonyme de SUBSTRING(str,pos,len).

• OCT(N)

  Retourne une chaîne de caractères représentant la valeur octale de l'argument N, où l'argument N est un nombre de type BIGINT. Cette fonction est un équivalent de CONV(N,10,8). Retourne NULL si l'argument N est NULL :

   

  Sélectionnez

  mysql> SELECT OCT(12);
          -> '14'

• OCTET_LENGTH(str)

  OCTET_LENGTH() est un synonyme de LENGTH().

• ORD(str)

  Si le premier caractère de la chaîne str est un caractère multioctet, la fonction retourne le code de ce caractère, calculé à partir du code ASCII retourné par cette formule :

   

  Sélectionnez

    (1st octet * 256)
  + (2nd octet * 256^2)
  + (3rd octet * 256^3) ...

  Si le premier caractère n'est pas un caractère multioctet, la fonction retournera la même valeur que la fonction ASCII() :

   

  Sélectionnez

  mysql> SELECT ORD('2');
          -> 50

• POSITION(substr IN str)

  POSITION(substr IN str) est un synonyme de LOCATE(substr,str).

• QUOTE(str)

  Échappe les caractères d'une chaîne pour produire un résultat qui sera exploitable dans une requête SQL. Les caractères suivants seront précédés d'un antislash dans la chaîne retournée : le guillemet simple ('''), l'antislash ('\'), ASCII NUL, et le Contrôle-Z. Si l'argument vaut NULL, la valeur retournée sera le mot « NULL » sans les guillemets simples. La fonction QUOTE a été ajoutée en MySQL version 4.0.3.

   

  Sélectionnez

  mysql> SELECT QUOTE("Don't");
          -> 'Don\'t!'
  mysql> SELECT QUOTE(NULL);
          -> NULL

• REPEAT(str,count)

  Retourne une chaîne de caractères constituée de la répétition de count fois la chaîne str. Si count <= 0, retourne une chaîne vide. Retourne NULL si str ou count sont NULL :

   

  Sélectionnez

  mysql> SELECT REPEAT('MySQL', 3);
          -> 'MySQLMySQLMySQL'

• REPLACE(str,from_str,to_str)

  Retourne une chaîne de caractères str dont toutes les occurrences de la chaîne from_str sont remplacées par la chaîne to_str :

   

  Sélectionnez

  mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
          -> 'WwWwWw.mysql.com'

  Cette fonction gère les caractères multioctets.

• REVERSE(str)

  Retourne une chaîne dont l'ordre des caractères est l'inverse de la chaîne str :

   

  Sélectionnez

  mysql> SELECT REVERSE('abc');
          -> 'cba'

  Cette fonction gère les caractères multioctets.

• RIGHT(str,len)

  Retourne les len caractères les plus à droite de la chaîne de caractères str :

   

  Sélectionnez

  mysql> SELECT RIGHT('foobarbar', 4);
          -> 'rbar'

  Cette fonction gère les caractères multioctets.

• RPAD(str,len,padstr)

  Retourne la chaîne de caractères str, complétée à droite par la chaîne de caractères padstr jusqu'à ce que la chaîne de caractères str atteigne len caractères de long. Si la chaîne de caractères str est plus longue que len caractères, elle sera raccourcie à len caractères.

   

  Sélectionnez

  mysql> SELECT RPAD('hi',5,'?');
          -> 'hi???'

• RTRIM(str)

  Retourne la chaîne de caractères str sans les espaces finals :

   

  Sélectionnez

  mysql> SELECT RTRIM('barbar   ');
          -> 'barbar'

  Cette fonction gère les caractères multioctets.

• SOUNDEX(str)

  Retourne la valeur Soundex de la chaîne de caractères str. Deux chaînes qui ont des sonorités proches auront des valeurs soundex proches. Une chaîne Soundex standard possède 4 caractères, mais la fonction SOUNDEX() retourne une chaîne de longueur arbitraire. Vous pouvez utiliser la fonction SUBSTRING() sur ce résultat pour obtenir une chaîne Soundex standard. Tout caractère non alphanumérique sera ignoré. Tous les caractères internationaux qui ne font pas partie de l'alphabet de base (A-Z) seront considérés comme des voyelles :

   

  Sélectionnez

  mysql> SELECT SOUNDEX('Hello');
          -> 'H400'
  mysql> SELECT SOUNDEX('Quadratically');
          -> 'Q36324'

  Note : cette fonction implémente l'algorithme soundex original, et non la version populaire améliorée (aussi décrite par D. Knuth). La différence est que la version originale supprime les voyelles, puis les doublons, alors que la version améliorée supprime les doublons d'abord, et ensuite, les voyelles.

• expr1 SOUNDS LIKE expr2

  Identique à SOUNDEX(expr1)=SOUNDEX(expr2) (disponible depuis la version 4.1).

• SPACE(N)

  Retourne une chaîne constituée de N espaces :

   

  Sélectionnez

  mysql> SELECT SPACE(6);
          -> '      '

• SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,len), SUBSTRING(str FROM pos FOR len)

  Retourne une chaîne de len 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 :

   

  Sélectionnez

  mysql> SELECT SUBSTRING('Quadratically',5);
          -> 'ratically'
  mysql> SELECT SUBSTRING('foobarbar' FROM 4);
          -> 'barbar'
  mysql> SELECT SUBSTRING('Quadratically',5,6);
          -> 'ratica'

  Cette fonction gère les caractères multioctets.

• SUBSTRING_INDEX(str,delim,count)

  Retourne une portion de la chaîne de caractères str, située avant count occurrences du délimiteur delim. Si l'argument count est positif, tout ce qui précède le délimiteur final sera retourné. Si l'argument count est négatif, tout ce qui suit le délimiteur final sera retourné :

   

  Sélectionnez

  mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
          -> 'www.mysql'
  mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
          -> 'mysql.com'

  Cette fonction gère les caractères multioctets.

• 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. Si aucun des spécificateurs BOTH, LEADING ou TRAILING n'est fourni, BOTH est utilisé comme valeur par défaut. Si remstr n'est pas spécifié, les espaces sont supprimés :

   

  Sélectionnez

  mysql> SELECT TRIM('  bar   ');
          -> 'bar'
  mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
          -> 'barxxx'
  mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
          -> 'bar'
  mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
          -> 'barx'

  Cette fonction gère les caractères multioctets.

• UCASE(str)

  UCASE() est un synonyme de UPPER().

• UNCOMPRESS(string_to_uncompress)

  Décompresse une chaîne compressée avec COMPRESS(). Si l'argument 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 toujours NULL.

   

  Sélectionnez

  mysql> SELECT UNCOMPRESS(COMPRESS('any string'));
          -> 'any string'
  mysql> SELECT UNCOMPRESS('any string');
          -> NULL

  UNCOMPRESS() a été ajoutée en MySQL 4.1.1.

• UNCOMPRESSED_LENGTH(compressed_string)

  Retourne la taille de la chaîne avant compression.

   

  Sélectionnez

  mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));
          -> 30

  UNCOMPRESSED_LENGTH() a été ajoutée en MySQL 4.1.1.

• UNHEX(str)

  Le contraire de HEX(string). C'est-à-dire, chaque paire de chiffres hexadécimaux est interprétée comme des nombres, et convertie en un caractère représenté par le nombre. Le résultat est retourné sous forme de chaîne binaire.

   

  Sélectionnez

  mysql> SELECT UNHEX('4D7953514C');
          -> 'MySQL'
  mysql> SELECT 0x4D7953514C;
          -> 'MySQL'
  mysql> SELECT UNHEX(HEX('string'));
          -> 'string'
  mysql> SELECT HEX(UNHEX('1267'));
          -> '1267'

  UNHEX() a été ajoutée en MySQL 4.1.2.

• UPPER(str)

  Retourne la chaîne str en majuscules, en fonction du jeu de caractères courant. Par défaut, c'est le jeu ISO-8859-1 Latin1 :

   

  Sélectionnez

  mysql> SELECT UPPER('Hey');
          -> 'HEY'

  Cette fonction gère les caractères multioctets.

12-3-1. Opérateurs de comparaison pour les chaînes de caractères▲

mysql> SELECT 1+'1';
        -> 2
mysql> SELECT CONCAT(2,' test');
        -> '2 test'

mysql> SELECT 38.8, CAST(38.8 AS CHAR);
        -> 38.8, '38.8'
mysql> SELECT 38.8, CONCAT(38.8);
        -> 38.8, '38.8'

12-4-1. Opérations arithmétiques▲

12-4-2. Fonctions mathématiques▲

Cette section décrit les fonctions qui peuvent être utilisées pour manipuler les valeurs temporelles. Voir Section 11.3, « Les types date et heure »11.3. Les types date et heure pour une description détaillée des intervalles de validité de chaque type, ainsi que les formats valides de spécifications des dates et heures.

Voici un exemple d'utilisation des fonctions de dates. La requête suivante sélectionne toutes les lignes dont la colonne date_col représente une date de moins de 30 jours :

mysql> SELECT quelquechose FROM nom_de_table
           WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;

Notez que cette requête va aussi sélectionner des lignes dont les dates sont dans le futur.

Les fonctions qui utilisent des valeurs de date acceptent les valeurs de type DATETIME et ignore la partie horaire. Les fonctions qui attendent des heures acceptent les valeurs littérales et ignorent la partie de date.

Les fonctions qui retournent la date ou l'heure courante sont évaluées une fois par requête, tout au début. Cela signifie que des références multiples à la fonction NOW() dans une même requête produiront toujours le même résultat. Ce principe s'applique aussi à CURDATE(), CURTIME(), UTC_DATE(), UTC_TIME(), UTC_TIMESTAMP(), et leurs synonymes.

Les intervalles de valeurs de retour des fonctions suivantes s'appliquent aux dates complètes. Si une date est une valeur « zéro » ou une date incomplète, comme '2001-11-00', les fonctions qui extraient une partie d'une date retourneront 0. Par exemple, DAYOFMONTH('2001-11-00') retourne 0.

• ADDDATE(date,INTERVAL expr type), ADDDATE(expr,days)

  Lorsqu'elle est utilisée avec la forme INTERVAL, ADDDATE() est un synonyme de DATE_ADD(). La fonction complémentaire SUBDATE() est un synonyme DATE_SUB().

   

  Sélectionnez

  mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
          -> '1998-02-02'
  mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
          -> '1998-02-02'

  Depuis MySQL 4.1.1, la seconde syntaxe est utilisée si expr est une expression de type DATE ou DATETIME, et que days est un nombre de jours à ajouter à expr.

   

  Sélectionnez

  mysql> SELECT ADDDATE('1998-01-02', 31);
          -> '1998-02-02'

• 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.

   

  Sélectionnez

  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 :

   

  Sélectionnez

  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()

  Retourne l'heure courante au format 'HH:MM:SS' or HHMMSS suivant le contexte numérique ou chaîne :

   

  Sélectionnez

  mysql> SELECT CURTIME();
          -> '23:50:26'
  mysql> SELECT CURTIME() + 0;
          -> 235026

• CURRENT_TIME, CURRENT_TIME()

  CURRENT_TIME et CURRENT_TIME() sont synonymes de CURTIME().

• CURRENT_TIMESTAMP, CURRENT_TIMESTAMP()

  CURRENT_TIMESTAMP et CURRENT_TIMESTAMP() sont synonymes de NOW().

• DATE(expr)

  Extrait la partie date de l'expression expr de type DATE ou DATETIME.

   

  Sélectionnez

  mysql> SELECT DATE('2003-12-31 01:02:03');
          -> '2003-12-31'

  DATE() est disponible depuis MySQL 4.1.1.

• DATEDIFF(expr,expr2)

  DATEDIFF() retourne le nombre de jours entre la date de début expr et la date de fin expr2. expr et expr2 sont des expressions de type DATE ou DATETIME. Seule la partie DATE est utilisée dans le calcul.

   

  Sélectionnez

  mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
          -> 1
  mysql> SELECT DATEDIFF('1997-11-31 23:59:59','1997-12-31');
          -> -30

  DATEDIFF() est disponible depuis MySQL 4.1.1.

• DATE_ADD(date,INTERVAL expr type), DATE_SUB(date,INTERVAL expr type)

  Ces fonctions effectuent des calculs arithmétiques sur les dates.

  Depuis MySQL 3.23, INTERVAL expr type est autorisé des deux côtés de l'opérateur + si l'expression de l'autre côté est de type DATE ou DATETIME. Pour l'opérateur -, INTERVAL expr type est autorisé uniquement du côté droit, car on ne peut pas soustraire une date d'un intervalle (voir les exemples ci-dessous).

  date est une valeur de type DATETIME ou DATE qui spécifie la date de début. expr est une expression qui spécifie une valeur d'intervalle à ajouter ou soustraire de la date initiale. expr est une chaîne : elle peut commencer avec '-' pour les intervalles négatifs. type est un mot-clé, indiquant comment l'expression doit être interprétée.

  Le tableau suivant indique la signification des arguments type et expr :

  type Valeur	Attendue expr Format
  MICROSECOND	MICROSECONDS
  SECOND	SECONDS
  MINUTE	MINUTES
  HOUR	HOURS
  DAY	DAYS
  WEEK	WEEKS
  MONTH	MONTHS
  QUARTER	QUARTERS
  YEAR	YEARS
  SECOND_MICROSECOND	'SECONDS.MICROSECONDS'
  MINUTE_MICROSECOND	'MINUTES.MICROSECONDS'
  MINUTE_SECOND	'MINUTES:SECONDS'
  HOUR_MICROSECOND	'HOURS.MICROSECONDS'
  HOUR_SECOND	'HOURS:MINUTES:SECONDS'
  HOUR_MINUTE	'HOURS:MINUTES'
  DAY_MICROSECOND	'DAYS.MICROSECONDS'
  DAY_SECOND	'DAYS HOURS:MINUTES:SECONDS'
  DAY_MINUTE	'DAYS HOURS:MINUTES'
  DAY_HOUR	'DAYS HOURS'
  YEAR_MONTH	'YEARS-MONTHS'

  Les valeurs de type DAY_MICROSECOND, HOUR_MICROSECOND, MINUTE_MICROSECOND, SECOND_MICROSECOND, et MICROSECOND ont été ajoutées en MySQL 4.1.1. Les valeurs QUARTER et WEEK sont disponibles depuis MySQL 5.0.0.

  MySQL autorise tous les signes de ponctuation, comme délimiteur dans le format de expr. Ceux qui sont affichés dans la table sont des suggestions. Si l'argument date est une valeur DATE et que vos calculs impliquent des parties YEAR, MONTH et DAY (c'est-à-dire, sans partie horaire), le résultat sera de type DATE. Sinon, le résultat est de type DATETIME :

   

  Sélectionnez

  mysql> SELECT '1997-12-31 23:59:59' + INTERVAL 1 SECOND;
          -> '1998-01-01 00:00:00'
  mysql> SELECT INTERVAL 1 DAY + '1997-12-31';
          -> '1998-01-01'
  mysql> SELECT '1998-01-01' - INTERVAL 1 SECOND;
          -> '1997-12-31 23:59:59'
  mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
      ->                 INTERVAL 1 SECOND);
          -> '1998-01-01 00:00:00'
  mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
      ->                 INTERVAL 1 DAY);
          -> '1998-01-01 23:59:59'
  mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
      ->                 INTERVAL '1:1' MINUTE_SECOND);
          -> '1998-01-01 00:01:00'
  mysql> SELECT DATE_SUB('1998-01-01 00:00:00',
      ->                 INTERVAL '1 1:1:1' DAY_SECOND);
          -> '1997-12-30 22:58:59'
  mysql> SELECT DATE_ADD('1998-01-01 00:00:00',
      ->                 INTERVAL '-1 10' DAY_HOUR);
          -> '1997-12-30 14:00:00'
  mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
          -> '1997-12-02'
  mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
      ->                 INTERVAL '1.999999' SECOND_MICROSECOND);
          -> '1993-01-01 00:00:01.000001'

  Si vous spécifiez un intervalle qui est trop court (il n'inclut pas toutes les parties d'intervalle attendues par type), MySQL suppose que vous avez omis les valeurs de gauche. Par exemple, si vous spécifiez un type type de DAY_SECOND, la valeur expr devrait contenir des jours, heures, minutes et secondes. Si vous fournissez une valeur de la forme '1:10', MySQL suppose que les jours et heures manquent, et que la valeur représente des minutes et secondes. En d'autres termes, '1:10' DAY_SECOND est interprété comme '1:10' MINUTE_SECOND. C'est similaire au comportement de MySQL avec les valeurs de type TIME, qui représente des durées plutôt que des horaires.

  Notez que si vous ajoutez ou soustrayez à une valeur de type DATE des horaires, le résultat sera automatiquement au format DATETIME :

   

  Sélectionnez

  mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 DAY);
          -> '1999-01-02'
  mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
          -> '1999-01-01 01:00:00'

  Si vous utilisez des dates mal formées, le résultat sera NULL. Si vous ajoutez des MONTH, YEAR_MONTH ou YEAR, et que le résultat a un jour du mois qui est au-delà de ce qui est possible dans le mois, le jour sera adapté au plus grand jour possible du mois. Par exemple :

   

  Sélectionnez

  mysql> SELECT DATE_ADD('1998-01-30', interval 1 month);
          -> '1998-02-28'

  Notez que dans l'exemple précédent, le mot-clé INTERVAL et le spécificateur type sont insensibles à la casse.

• DATE_FORMAT(date,format)

  Formate la date date avec le format format. Les spécificateurs suivants peuvent être utilisés dans la chaîne format :

  Option	Description
  %%	Un signe pourcentage littéral '%'
  %a	Nom du jour de la semaine, en abrégé et en anglais (Sun..Sat)
  %b	Nom du mois, en abrégé et en anglais (Jan..Dec)
  %c	Mois, au format numérique (1..12)
  %d	Jour du mois, au format numérique (00..31)
  %D	Jour du mois, avec un suffixe anglais (1st, 2nd, 3rd, etc.)
  %e	Jour du mois, au format numérique (0..31)
  %f	Microsecondes (000000..999999)
  %H	Heure (00..23)
  %h	Heure (01..12)
  %I	Heure (01..12)
  %i	Minutes, au format numérique (00..59)
  %j	Jour de l'année (001..366)
  %k	Heure (0..23)
  %l	Heure (1..12)
  %m	Mois, au format numérique (01..12)
  %M	Nom du mois (January..December)
  %p	AM ou PM
  %r	Heures, au format 12 heures (hh:mm:ss [AP]M)
  %s	Secondes (00..59)
  %S	Secondes (00..59)
  %T	Heures, au format 24 heures (hh:mm:ss)
  %U	Numéro de la semaine (00..53), où dimanche est le premier jour de la semaine
  %u	Numéro de la semaine (00..53), où lundi est le premier jour de la semaine
  %V	Numéro de la semaine (01..53), où dimanche est le premier jour de la semaine, utilisé avec '%X'
  %v	Numéro de la semaine (01..53), où lundi est le premier jour de la semaine, utilisé avec '%x'
  %W	Nom du jour de la semaine (Sunday..Saturday)
  %w	Numéro du jour de la semaine (0=Sunday..6=Saturday)
  %X	Année, pour les semaines qui commencent le dimanche, au format numérique, sur 4 chiffres, utilisé avec '%V'
  %x	Année, pour les semaines qui commencent le lundi, au format numérique, sur 4 chiffres, utilisé avec '%v'
  %y	Année, au format numérique, sur 2 chiffres
  %Y	Année, au format numérique, sur 4 chiffres

  Tous les autres caractères sont simplement copiés dans le résultat sans interprétation.

  Le format %f est disponible depuis MySQL 4.1.1.

  Depuis MySQL version 3.23, le caractère '%' est requis devant les caractères de format. Dans les versions antérieures de MySQL, '%' était optionnel.

  La raison qui fait que les intervalles de mois et de jours commencent avec zéro est que MySQL autorise les dates incomplètes comme '2004-00-00', depuis MySQL 3.23.

   

  Sélectionnez

  mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
          -> 'Saturday October 1997'
  mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');
          -> '22:23:00'
  mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
                            '%D %y %a %d %m %b %j');
          -> '4th 97 Sat 04 10 Oct 277'
  mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
                            '%H %k %I %r %T %S %w');
          -> '22 22 10 10:23:00 PM 22:23:00 00 6'
  mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');
          -> '1998 52'

• DAY(date)

  DAY() est un synonyme de DAYOFMONTH(). Cette fonction est disponible depuis MySQL 4.1.1.

• DAYNAME(date)

  Retourne le nom du jour de la semaine de date :

   

  Sélectionnez

  mysql> SELECT DAYNAME('1998-02-05');
          -> 'Thursday'

• DAYOFMONTH(date)

  Retourne le jour de la date date, dans un intervalle de 1 à 31 :

   

  Sélectionnez

  mysql> SELECT DAYOFMONTH('1998-02-03');
          -> 3

• DAYOFWEEK(date)

  Retourne l'index du jour de la semaine : pour date (1 = dimanche, 2 = lundi, ... 7 = samedi). Ces index correspondent au standard ODBC :

   

  Sélectionnez

  mysql> SELECT DAYOFWEEK('1998-02-03');
          -> 3

• DAYOFYEAR(date)

  Retourne le jour de la date date, dans un intervalle de 1 à 366 :

   

  Sélectionnez

  mysql> SELECT DAYOFYEAR('1998-02-03');
          -> 34

• EXTRACT(type FROM date)

  La fonction EXTRACT() utilise les mêmes types d'intervalles que la fonction DATE_ADD() ou la fonction DATE_SUB(), mais extrait des parties de dates plutôt que des opérations de dates.

   

  Sélectionnez

  mysql> SELECT EXTRACT(YEAR FROM "1999-07-02");
         -> 1999
  mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");
         -> 199907
  mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");
         -> 20102
  mysql> SELECT EXTRACT(MICROSECOND FROM "2003-01-02 10:30:00.00123");
          -> 123

• FROM_DAYS(N)

  Retourne la date correspondant au nombre de jours (N) depuis la date 0 :

   

  Sélectionnez

  mysql> SELECT FROM_DAYS(729669);
          -> '1997-10-07'

  FROM_DAYS() n'est pas fait pour travailler avec des dates qui précèdent l'avènement du calendrier grégorien (1582), car elle ne prend pas en compte les jours perdus lors du changement de calendrier.

• FROM_UNIXTIME(unix_timestamp)

  Retourne une représentation de l'argument unix_timestamp sous la forme 'YYYY-MM-DD HH:MM:SS' ou YYYYMMDDHHMMSS, suivant si la fonction est utilisée dans un contexte numérique ou de chaîne.

   

  Sélectionnez

  mysql> SELECT FROM_UNIXTIME(875996580);
          -> '1997-10-04 22:23:00'
  mysql> SELECT FROM_UNIXTIME(875996580) + 0;
          -> 19971004222300

  Si format est donné, le résultat est formaté en fonction de la chaîne format. format peut contenir les mêmes options de format que celles utilisées par DATE_FORMAT() :

   

  Sélectionnez

  mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),
      ->                      '%Y %D %M %h:%i:%s %x');
          -> '2003 6th August 06:22:58 2003'

• GET_FORMAT(DATE | TIME | TIMESTAMP, 'EUR' | 'USA' | 'JIS' | 'ISO' | 'INTERNAL')

  Retourne une chaîne de format. Cette fonction est pratique lorsqu'elle est utilisée avec les fonctions DATE_FORMAT() et STR_TO_DATE().

  Les trois valeurs possibles pour le premier argument, et les cinq valeurs possibles pour le second argument donnent 15 formats d'affichage (pour les options utilisées, voyez le tableau de la fonction DATE_FORMAT()) :

  Appel fonction	Résultat
  GET_FORMAT(DATE,'USA')	'%m.%d.%Y'
  GET_FORMAT(DATE,'JIS')	'%Y-%m-%d'
  GET_FORMAT(DATE,'ISO')	'%Y-%m-%d'
  GET_FORMAT(DATE,'EUR')	'%d.%m.%Y'
  GET_FORMAT(DATE,'INTERNAL')	'%Y%m%d'
  GET_FORMAT(TIMESTAMP,'USA')	'%Y-%m-%d-%H.%i.%s'
  GET_FORMAT(TIMESTAMP,'JIS')	'%Y-%m-%d %H:%i:%s'
  GET_FORMAT(TIMESTAMP,'ISO')	'%Y-%m-%d %H:%i:%s'
  GET_FORMAT(TIMESTAMP,'EUR')	'%Y-%m-%d-%H.%i.%s'
  GET_FORMAT(TIMESTAMP,'INTERNAL')	'%Y%m%d%H%i%s'
  GET_FORMAT(TIME,'USA')	'%h:%i:%s %p'
  GET_FORMAT(TIME,'JIS')	'%H:%i:%s'
  GET_FORMAT(TIME,'ISO')	'%H:%i:%s'
  GET_FORMAT(TIME,'EUR')	'%H.%i.%S'
  GET_FORMAT(TIME,'INTERNAL')	'%H%i%s'

  Le format ISO est le format ISO 9075, et non ISO 8601.

   

  Sélectionnez

  mysql> SELECT DATE_FORMAT('2003-10-03', GET_FORMAT(DATE, 'EUR')
          -> '03.10.2003'
  mysql> SELECT STR_TO_DATE('10.31.2003', GET_FORMAT(DATE, 'USA'))
          -> 2003-10-31

  GET_FORMAT() est disponible depuis MySQL 4.1.1. Voyez Voir Section 13.5.2.8, « Syntaxe de SET »13.5.2.8. Syntaxe de SET.

• HOUR(time)

  Retourne le nombre d'heures pour l'heure time, dans un intervalle de 0 à 23 :

   

  Sélectionnez

  mysql> SELECT HOUR('10:05:03');
          -> 10

  Cependant, l'intervalle des valeurs TIME est bien plus grand, et donc, HOUR peut retourner des valeurs plus grandes que 23 :

   

  Sélectionnez

  mysql> SELECT HOUR('272:59:59');
          -> 272

• LAST_DAY(date)

  Prend une valeur de format DATE ou DATETIME, et retourne le dernier jour du mois correspondant. Retourne NULL si l'argument est invalide.

   

  Sélectionnez

  mysql> SELECT LAST_DAY('2003-02-05'), LAST_DAY('2004-02-05');
          -> '2003-02-28', '2004-02-29'
  mysql> SELECT LAST_DAY('2004-01-01 01:01:01');
          -> '2004-01-31'
  mysql> SELECT LAST_DAY('2003-03-32');
          -> NULL

  LAST_DAY() est disponible depuis MySQL 4.1.1.

• LOCALTIME, LOCALTIME()

  LOCALTIME et LOCALTIME() sont synonymes de NOW().

• LOCALTIMESTAMP, LOCALTIMESTAMP()

  LOCALTIMESTAMP et LOCALTIMESTAMP() sont synonymes de NOW().

• MAKEDATE(year,dayofyear)

  Retourne une valeur de format DATE, à partir d'une année et du numéro de jour. dayofyear doit être plus grand que 0 ou le résultat sera NULL.

   

  Sélectionnez

  mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
          -> '2001-01-31', '2001-02-01'
  mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365);
          -> '2001-12-31', '2004-12-30'
  mysql> SELECT MAKEDATE(2001,0);
          -> NULL

  MAKEDATE() est disponible depuis MySQL 4.1.1.

• MAKETIME(hour,minute,second)

  Retourne une valeur de format TIME, calculée à partir des arguments hour, minute et second.

   

  Sélectionnez

  mysql> SELECT MAKETIME(12,15,30);
          -> '12:15:30'

  MAKETIME() est disponible depuis MySQL 4.1.1.

• MICROSECOND(expr)

  Retourne le nombre de microsecondes dans l'expression de type TIME ou DATETIME expr, sous la forme d'un nombre entre 0 et 999999.

   

  Sélectionnez

  mysql> SELECT MICROSECOND('12:00:00.123456');
          -> 123456
  mysql> SELECT MICROSECOND('1997-12-31 23:59:59.000010');
          -> 10

  MICROSECOND() est disponible depuis MySQL 4.1.1.

• MINUTE(time)

  Retourne le nombre de minutes pour l'heure time, dans un intervalle de 0 à 59 :

   

  Sélectionnez

  mysql> SELECT MINUTE('98-02-03 10:05:03');
          -> 5

• MONTH(date)

  Retourne le numéro du mois de la date date, dans un intervalle de 1 à 12 :

   

  Sélectionnez

  mysql> SELECT MONTH('1998-02-03');
          -> 2

• MONTHNAME(date)

  Retourne le nom du mois de la date date :

   

  Sélectionnez

  mysql> SELECT MONTHNAME("1998-02-05");
          -> 'February'

• NOW()

  Retourne la date courante au format 'YYYY-MM-DD HH:MM:SS' ou YYYYMMDDHHMMSS, suivant le contexte numérique ou chaîne :

   

  Sélectionnez

  mysql> SELECT NOW();
          -> '1997-12-15 23:50:26'
  mysql> SELECT NOW() + 0;
          -> 19971215235026

• PERIOD_ADD(P,N)

  Ajoute N mois à la période P (au format YYMM ou YYYYMM). Retourne une valeur dans le format YYYYMM.

  Notez que l'argument P n'est pas de type date :

   

  Sélectionnez

  mysql> SELECT PERIOD_ADD(9801,2);
          -> 199803

• PERIOD_DIFF(P1,P2)

  Retourne le nombre de mois entre les périodes P1 et P2. P1 et P2 doivent être au format YYMM ou YYYYMM.

  Notez que les arguments P1 et P2 ne sont pas de type date :

   

  Sélectionnez

  mysql> SELECT PERIOD_DIFF(9802,199703);
          -> 11

• QUARTER(date)

  Retourne le numéro du trimestre de la date date, dans un intervalle de 1 à 4 :

   

  Sélectionnez

  mysql> SELECT QUARTER('98-04-01');
          -> 2

• SECOND(time)

  Retourne le nombre de secondes pour l'heure time, dans un intervalle de 0 à 59 :

   

  Sélectionnez

  mysql> SELECT SECOND('10:05:03');
          -> 3

• SEC_TO_TIME(seconds)

  Retourne l'argument seconds, converti en heures, minutes et secondes au format 'HH:MM:SS' ou HHMMSS, suivant le contexte numérique ou chaîne :

   

  Sélectionnez

  mysql> SELECT SEC_TO_TIME(2378);
          -> '00:39:38'
  mysql> SELECT SEC_TO_TIME(2378) + 0;
          -> 3938

• STR_TO_DATE(str,format)

  Cette fonction est l'inverse de la fonction DATE_FORMAT(). Elle prend la chaîne str, et une chaîne de format format, puis retourne une valeur DATETIME.

  Les valeurs de type DATE, TIME ou DATETIME contenues dans la chaîne str doivent être au format format. Pour les options qui sont utilisables dans la chaîne format, voyez le tableau dans la description de la fonction DATE_FORMAT(). Tous les autres caractères sont utilisés littéralement, et ne seront pas interprétés. Si str contient une valeur illégale, STR_TO_DATE() retourne NULL.

   

  Sélectionnez

  mysql> SELECT STR_TO_DATE('03.10.2003 09.20', '%d.%m.%Y %H.%i')
          -> 2003-10-03 09:20:00
  mysql> SELECT STR_TO_DATE('10rap', '%crap')
          -> 0000-10-00 00:00:00
  mysql> SELECT STR_TO_DATE('2003-15-10 00:00:00', '%Y-%m-%d %H:%i:%s')
          -> NULL

  STR_TO_DATE() est disponible depuis MySQL 4.1.1.

• SUBDATE(date,INTERVAL expr type), SUBDATE(expr,days)

  Lorsqu'elle est utilisée avec la forme INTERVAL du second argument, SUBDATE() est synonyme DATE_SUB().

   

  Sélectionnez

  mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
          -> '1997-12-02'
  mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
          -> '1997-12-02'

  Depuis MySQL 4.1.1, la seconde syntaxe est autorisée, où expr est une expression de type DATE ou DATETIME et days est le nombre de jours à soustraire de l'expression expr.

   

  Sélectionnez

  mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31);
          -> '1997-12-02 12:00:00'

• SUBTIME(expr,expr2)

  SUBTIME() soustrait expr2 de expr et retourne le résultat. expr est une expression de format DATE ou DATETIME et expr2 est une expression de type TIME.

   

  Sélectionnez

  mysql> SELECT SUBTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002");
          -> '1997-12-30 22:58:58.999997'
  mysql> SELECT SUBTIME("01:00:00.999999", "02:00:00.999998");
          -> '-00:59:59.999999'

  SUBTIME() a été ajoutée en MySQL 4.1.1.

• SYSDATE()

  SYSDATE() est un synonyme de NOW().

• TIME(expr)

  Extrait la partie horaire de l'expression expr, de type TIME ou DATETIME.

   

  Sélectionnez

  mysql> SELECT TIME('2003-12-31 01:02:03');
          -> '01:02:03'
  mysql> SELECT TIME('2003-12-31 01:02:03.000123');
          -> '01:02:03.000123'

  TIME() a été ajoutée en MySQL 4.1.1.

• TIMEDIFF(expr,expr2)

  TIMEDIFF() retourne la durée entre l'heure de début expr et l'heure de fin expr2. expr et expr2 sont des expressions de type TIME ou DATETIME, et doivent être de même type.

   

  Sélectionnez

  mysql> SELECT TIMEDIFF('2000:01:01 00:00:00', '2000:01:01 00:00:00.000001');
          -> '-00:00:00.000001'
  mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001','1997-12-30 01:01:01.000002');
          -> '46:58:57.999999'

  TIMEDIFF() a été ajoutée en MySQL 4.1.1.

• TIMESTAMP(expr), TIMESTAMP(expr,expr2)

  Avec un seul argument, retourne l'expression expr de type DATE ou DATETIME sous la forme d'une valeur DATETIME. Avec deux arguments, ajouter l'expression expr2 à l'expression expr et retourne le résultat au format DATETIME.

   

  Sélectionnez

  mysql> SELECT TIMESTAMP('2003-12-31');
          -> '2003-12-31 00:00:00'
  mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');
          -> '2004-01-01 00:00:00'

  TIMESTAMP() a été ajoutée en MySQL 4.1.1.

• TIMESTAMPADD(interval,int_expr,datetime_expr)

  Ajoute l'expression entière int_expr à l'expression datetime_expr au format DATE ou DATETIME. L'unité de int_expr est donnée avec l'argument interval, qui peut être l'une des valeurs suivantes : FRAC_SECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, ou YEAR.

  La valeur interval peut être spécifiée, en utilisant un des mots-clés cités, ou avec le préfixe SQL_TSI_. Par exemple, DAY et SQL_TSI_DAY sont tous les deux valides.

   

  Sélectionnez

  mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
          -> '2003-01-02 00:01:00'
  mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02');
          -> '2003-01-09'

  TIMESTAMPADD() a été ajoutée en MySQL 5.0.0.

• TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2)

  Retourne la différence entière entre les expressions datetime_expr1 et datetime_expr2, de format DATE et DATETIME. L'unité du résultat est donnée par l'argument interval. Les valeurs légales de interval sont les mêmes que pour la fonction TIMESTAMPADD().

   

  Sélectionnez

  mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
          -> 3
  mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');
          -> -1

  TIMESTAMPDIFF() a été ajoutée en MySQL 5.0.0.

• TIME_FORMAT(time,format)

  Cette fonction est utilisée exactement comme la fonction DATE_FORMAT() ci-dessus, mais la chaîne format ne doit utiliser que des spécificateurs d'heures, qui gèrent les heures, minutes et secondes. Les autres spécificateurs génèreront la valeur NULL ou 0.

  Si la valeur time contient une valeur d'heure qui est plus grande que 23, les formats %H et %k produiront une valeur qui est hors de l'intervalle 0..23. L'autre format d'heure produira une heure modulo 12 :

   

  Sélectionnez

  mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
          -> '100 100 04 04 4'

• TIME_TO_SEC(time)

  Retourne l'argument time, converti en secondes :

   

  Sélectionnez

  mysql> SELECT TIME_TO_SEC('22:23:00');
          -> 80580
  mysql> SELECT TIME_TO_SEC('00:39:38');
          -> 2378

• TO_DAYS(date)

  Retourne le nombre de jours depuis la date 0 jusqu'à la date date :

   

  Sélectionnez

  mysql> SELECT TO_DAYS(950501);
          -> 728779
  mysql> SELECT TO_DAYS('1997-10-07');
          -> 729669

  TO_DAYS() n'est pas fait pour travailler avec des dates qui précèdent l'avènement du calendrier grégorien (1582), car elle ne prend pas en compte les jours perdus lors du changement de calendrier.

  N'oubliez pas que MySQL convertit les années représentées sur deux chiffres en dates à quatre chiffres, en utilisant les règles de la section Section 11.3, « Les types date et heure »11.3. Les types date et heure. Par exemple, '1997-10-07' et '97-10-07' sont identiques :

   

  Sélectionnez

  mysql> SELECT TO_DAYS('1997-10-07'), TO_DAYS('97-10-07');
          -> 729669, 729669

  Pour les dates antérieures à 1582, les résultats sont indéfinis.

• UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)

  Lorsqu'elle est appelée sans argument, cette fonction retourne un timestamp Unix (nombre de secondes depuis '1970-01-01 00:00:00' GMT). Si UNIX_TIMESTAMP() est appelée avec un argument date, elle retourne le timestamp correspondant à cette date. date peut être une chaîne de type DATE, DATETIME, TIMESTAMP, ou un nombre au format YYMMDD ou YYYYMMDD, en horaire local :

   

  Sélectionnez

  mysql> SELECT UNIX_TIMESTAMP();
          -> 882226357
  mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
          -> 875996580

  Lorsque UNIX_TIMESTAMP est utilisé sur une colonne de type TIMESTAMP, la fonction reçoit directement la valeur, sans conversion explicite. Si vous donnez à UNIX_TIMESTAMP() une date hors de son intervalle de validité, elle retourne 0.

  Si vous voulez soustraire une colonne de type UNIX_TIMESTAMP(), vous devez sûrement vouloir un résultat de type entier signé. Voir Section 12.7, « Fonctions de transtypage »12.7. Fonctions de transtypage.

• UTC_DATE, UTC_DATE()

  Retourne la date UTC courante au format 'YYYY-MM-DD' ou YYYYMMDD suivant le contexte numérique ou chaîne :

   

  Sélectionnez

  mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
          -> '2003-08-14', 20030814

  UTC_DATE() est disponible depuis MySQL 4.1.1.

• UTC_TIME, UTC_TIME()

  Retourne l'heure UTC courante au format 'HH:MM:SS' or HHMMSS suivant le contexte numérique ou chaîne :

   

  Sélectionnez

  mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
          -> '18:07:53', 180753

  UTC_TIME() est disponible depuis MySQL 4.1.1.

• UTC_TIMESTAMP, UTC_TIMESTAMP()

  Retourne l'heure et la date UTC courante au format 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS suivant le contexte numérique ou chaîne :

   

  Sélectionnez

  mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
          -> '2003-08-14 18:08:04', 20030814180804

  UTC_TIMESTAMP() est disponible depuis MySQL 4.1.1.

• WEEK(date [,mode])

  Avec un seul argument, retourne le numéro de la semaine dans l'année de la date date, dans un intervalle de 0 à 53 (oui, il peut y avoir un début de semaine numéro 53), en considérant que dimanche est le premier jour de la semaine. Avec deux arguments, la fonction WEEK() vous permet de spécifier si les semaines commencent le dimanche ou le lundi et la valeur retournée sera dans l'intervalle 0-53 ou bien 1-52. Lorsque l'argument mode est omis, la valeur de la variable default_week_format (ou 0 en MySQL 4.0 ou plus ancien) est utilisé. Voir Section 13.5.2.8, « Syntaxe de SET »13.5.2.8. Syntaxe de SET.

  Voici un tableau explicatif sur le fonctionnement du second argument :

  Valeur	Signification
  0	La semaine commence le Sunday ; l'intervalle de valeur de retour va de 0 à 12 ; la semaine 1 est la première semaine de l'année
  1	La semaine commence le Monday ; l'intervalle de valeur de retour va de 0 à 12 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours
  2	La semaine commence le Sunday ; l'intervalle de valeur de retour va de 1 à 12 ; la semaine 1 est la première semaine de l'année
  3	La semaine commence le Monday ; l'intervalle de valeur de retour va de 1 à 12 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours
  4	La semaine commence le Sunday ; l'intervalle de valeur de retour va de 0 à 12 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours
  5	La semaine commence le Monday ; l'intervalle de valeur de retour va de 0 à 12 ; la semaine 1 est la première semaine de l'année
  6	La semaine commence le Sunday ; l'intervalle de valeur de retour va de 1 à 12 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours
  7	La semaine commence le Monday ; l'intervalle de valeur de retour va de 1 à 12 ; la semaine 1 est la première semaine de l'année

  Le mode 3 est disponible depuis MySQL 4.0.5. Le mode 4 est disponible depuis MySQL 4.0.17.

   

  Sélectionnez

  mysql> SELECT WEEK('1998-02-20');
          -> 7
  mysql> SELECT WEEK('1998-02-20',0);
          -> 7
  mysql> SELECT WEEK('1998-02-20',1);
          -> 8
  mysql> SELECT WEEK('1998-12-31',1);
          -> 53

  Note : en version 4.0, WEEK(date,0) a été modifiée pour correspondre au système calendaire des USA. Avant cela, WEEK() était calculé incorrectement, pour des dates américaines : en effet, WEEK(date) et WEEK(date,0) étaient incorrects.

  Si vous préférez que le résultat soit calculé en fonction de l'année qui contient le premier jour de la semaine de la date utilisée en argument, vous devriez utiliser les valeurs 2, 3, 6, or 7 de l'argument mode.

   

  Sélectionnez

  mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);
          -> 2000, 0
  mysql> SELECT WEEK('2000-01-01',2);
          -> 52

  Alternativement, utilisez la fonction YEARWEEK() :

   

  Sélectionnez

  mysql> SELECT YEARWEEK('2000-01-01');
          -> 199952
  mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);
          -> '52'

• WEEKDAY(date)

  Retourne l'index du jour de la semaine, avec la conversion suivante : date (0 = lundi, 1 = mardi, ... 6 = dimanche).

   

  Sélectionnez

  mysql> SELECT WEEKDAY('1997-10-04 22:23:00');
          -> 5
  mysql> SELECT WEEKDAY('1997-11-05');
          -> 2

• WEEKOFYEAR(date)

  Retourne le numéro de semaine dans l'année, sous forme d'un nombre compris entre 1 et 53.

   

  Sélectionnez

  mysql> SELECT WEEKOFYEAR('1998-02-20');
          -> 8

  WEEKOFYEAR() est disponible depuis MySQL 4.1.1.

• YEAR(date)

  Retourne l'année de la date date, dans un intervalle de 1000 à 9999 :

   

  Sélectionnez

  mysql> SELECT YEAR('98-02-03');
          -> 1998

   

  Sélectionnez

  mysql> SELECT YEAR('98-02-03');
          -> 1998

• YEARWEEK(date), YEARWEEK(date,start)

  Retourne l'année et la semaine d'une date. L'argument start fonctionne exactement comme l'argument start de la fonction WEEK(). Notez que l'année dans le résultat peut être différente de l'année passée en argument, pour la première et la dernière semaine de l'année.

   

  Sélectionnez

  mysql> SELECT YEARWEEK('1987-01-01');
          -> 198653

  Notez que le numéro de semaine est différent de celui que la fonction WEEK() retourne (0) pour les arguments optionnels 0 ou 1, comme WEEK() puis retourne la semaine dans le contexte de l'année.