7.3 Fonctions utilisées dans les clauses SELECT et WHERE

Une clause select ou where dans une command SQL peut contenir des expressions utilisant les fonctions décrites ci-dessous.

Une expression qui contient une valeur aura toujours un résultat , sauf exceptions indiquées dans la documentation sur les opérateurs et fonctions.

Note: Il faut nécessairement un espace entre le nom de la fonction et la parenthèse ouvrante qui suit. Cela aide l'analyseur syntaxique de MySQL à faire la différence entre les appels de fonctions et les références aux tables ou colonnes qui interviennent dans la même colonne et qui ont le même nom que la fonction. Les espaces autours des arguments aussi autorisés.

Par souci de brièveté, les affichages d'exemples seront en mode réduit. Par exemple 

mysql> select MOD(29,9);
1 rows in set (0.00 sec)
+-----------+
| mod(29,9) |
+-----------+
|         2 |
+-----------+

Sera affiché comme suit : 


mysql> select MOD(29,9);
        -> 2

7.3.1 Fonction de groupement

( ... )
( ... )
Parenthèses. MySQL gère les priorités avec les parenthèses. 
mysql> select 1+2*3;
        -> 7
mysql> select (1+2)*3;
        -> 9
Parentheses. Use these to force the order of evaluation in an expression.

7.3.2 Opérations arithmétiques normales

Les opérateurs arithmétiques usuels sont disponible. Il faut bien noter que dans le cas de -, + et *, le resultat est calculé avec la précision BIGINT (64-bit) si les deux opérateurs sont des entiers.

  • + Addition 
    • mysql> select 3+5;
        -> 8
  • - Soustraction 
    mysql> select 3-5;
        -> -2
  • * Multiplication 
    mysql> select 3*5;
        -> 15
mysql> select 18014398509481984*18014398509481984.0;
        -> 324518553658426726783156020576256.0
mysql> select 18014398509481984*18014398509481984;
        -> 0

    Le résultat du dernier exemple est incorrect, car le résultat de la multiplication excède la taille maximale d'un BIGINT.

  • / Division 
    mysql> select 3/5;
        -> 0.60

    La division par zéro retourne une valeur NULL: 

    mysql> select 102/(1-1);
        -> NULL

    La division sera calculée avec l'arithmétique des BIGINT, uniquement dans le cas ou le résultat doit être converti en entier !

    7.3.3 Fonctions sur les bits

    MySQL utilise des BIGINT (64-bit) pour ses opérations sur les bits, donc tous les opérateurs suivants ont au portent au plus 64 bits.

  • | OU bit à bit 
    mysql> select 29 | 15;
        -> 31
  • & ET bit à bit 
    mysql> select 29 & 15;
        -> 13
  • << Décalage des bits vers la gauche sur un BIGINT. 
    mysql> select 1 << 2
        -> 4
  • >> Décalage des bits vers la droite sur un BIGINT. 
    mysql> select 4 >> 2
        -> 1
  • BIT_COUNT(N) Compte le nombre de bits mis à un dans l'argument N. 
    mysql> select BIT_COUNT(29);
        -> 4

    7.3.4 Opérations logiques

    Toutes les opérations logiques retournent 1 (TRUE) ou 0 (FALSE).

  • NOT
  • ! NON logique. Retourne 1 si l'argument est 0, sinon, retourne 0. Exception: NOT NULL retourne NULL. 
    mysql> select NOT 1;
        -> 0
mysql> select NOT NULL;
        -> NULL
mysql> select ! (1+1);
        -> 0
mysql> select ! 1+1;
        -> 1

    Le dernier exemple retourne 1 car l'expression est évaluée de la même façon que (!1)+1.

  • OR
  • || OU logique. Retourne 1 si l'un des arguments est ni 0 ni NULL. 
    mysql> select 1 || 0;
        -> 1
mysql> select 0 || 0;
        -> 0
mysql> select 1 || NULL;
        -> 1
  • AND
  • && ET logique. Retourne 0 si l'un des arguments est 0 ou NULL. Sinon, retourne 1. 
    mysql> select 1 && NULL;
        -> 0
mysql> select 1 && 0;
        -> 0

    7.3.5 Opérateurs de comparaison

    Les opérations de comparaison retourne soit 1 (TRUE), 0 (FALSE) ou NULL. Ces fonctions s'appliquent aussi bien aux nombres qu'aux chaînes. Les chaînes sont automatiquement converties en nombre et les nombres en chaîne, suivant les besoins (comme en Perl).

    MySQL effectue les comparaisons en suivant les règle suivantes

    • Si l'un au moins des argument est NULL, le résultat de la comparaison est NULL.
    • Si les deux argument sont des chaînes, ils se comparent en tant que chaînes.
    • Si les deux argument sont des entiers, ils se comparent en tant que entiers.
    • Si les deux argument est de type TIMESTAMP ou DATETIME, et l'autre argument est une constante, la constante est convertie au format TIMESTAMP avant la comparaison. Cette fonction est faite pour assurer la compatibilité ODBC.
    • Dans tous les autres cas, les arguments sont comparés en tant que nombre à virgule flottante.

    Par défaut, les comparaisons de chaîne sont fait sans tenir compte de la casse, et en utilisant le jeu de caractère courant (ISO-8859-1 Latin1 par défaut, qui fonctionne bien pour l'anglais). Les exemples suivants illustrent les règles de conversions lors des opérations de comparaison. 

    mysql> SELECT 1 > '6x';
         -> 0
mysql> SELECT 7 > '6x';
         -> 1
mysql> SELECT 0 > 'x6';
         -> 0
mysql> SELECT 0 = 'x6';
         -> 1
  • = Egalité. 
    mysql> select 1 = 0;
        -> 0
mysql> select '0' = 0;
        -> 1
mysql> select '0.0' = 0;
        -> 1
mysql> select '0.01' = 0;
        -> 0
mysql> select '.01' = 0.01;
        -> 1
  • <>
  • != Différent 
    mysql> select '.01' <> '0.01';
        -> 1
mysql> select .01 <> '0.01';
        -> 0
mysql> select 'zorro' <> 'zorrro';
        -> 1
  • <= Inférieur ou égal 
    mysql> select 0.1 <= 2;
        -> 1
  • < Strictement inférieur 
    mysql> select 2 <= 2;
        -> 1
  • >= Supérieur ou égal 
    mysql> select 2 >= 2;
        -> 1
  • > Strictement supérieur 
    mysql> select 2 > 2;
        -> 0
  • <=> Egalité : ce opérateur s'assure qu'on ne compare pas NULL et une valeur non nulle. 
    mysql> select 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
        -> 1 1 0
  • expression BETWEEN minimum AND maximum Si l'expression est comprise entre le minimum et le maximum, alors BETWEEN retourne 1, sinon 0. Cette fonction est équivalente à l'expression (minimum <= expression AND expression <= maximum) si tous les arguments sont du même type. Le premier argument (expression) détermine la manière dont la comparaison va être faite. Si expression est une chaîne, la comparaison sera de type chaîne, et insensible à la casse. Si expression est une chaîne de type binaire, la comparaison sera de type chaîne, et sensible à la casse. Si expression est un entier, la comparaison sera de type numérique. Si expression est un nombre à virgule flottante, la comparaison sera de type numérique, à virgule flottante. 
    mysql> select 1 BETWEEN 2 AND 3;
        -> 0
mysql> select 'b' BETWEEN 'a' AND 'c';
        -> 1
mysql> select 2 BETWEEN 2 AND '3';
        -> 1
mysql> select 2 BETWEEN 2 AND 'x-3';
        -> 0
  • expression IN (value,...) Retourne 1 si expression est un membre de la liste IN, sinon retourne 0.Si toutes les valeurs de la liste IN sont constantes, alors elles sont toutes converties au type de expression, et triées. La recherche dans la listes est alors faite avec une recherche binaire. Cela signifie que la recherche est très rapide si la liste IN ne contient que des constantes. Si expression est une chaîne sensible à la casse, la comparaison avec les valeurs de IN en tiendra compte. 
    mysql> select 2 IN (0,3,5,'wefwf');
        -> 0
mysql> select 'wefwf' IN (0,3,5,'wefwf');
        -> 1
  • expression NOT IN (value,...) Identique à NOT (expression IN (value,...)).
  • ISNULL(expression ) Si expression est NULL, ISNULL() retourne 1, sinon 0. 
    mysql> select ISNULL(1+1);
        -> 0
mysql> select ISNULL(1/0);
        -> 1

    Il faut noter que la comparaison à NULL avec = sera toujours fausse!

  • COALESCE(liste) Retourne le premier élément non NULL dans la liste. 
    mysql> select COALESCE(NULL,1);
        -> 1
mysql> select ISNULL(NULL,NULL,NULL);
        -> NULL
  • INTERVAL(N,N1,N2,N3,...) Retourne 1 si N1 < N2 < N3 < ... < Nn . Si il existe deux valeurs i et j, telles que i < j et Ni > Nj, alors la fonction retourne faux. Toutes les valeurs sont traitées comme des nombres. Cela permet l'utilisation d'une comparaison binaire, très rapide. 
    mysql> select INTERVAL(23, 1, 15, 17, 30, 44, 200);
        -> 3
mysql> select INTERVAL(10, 1, 10, 100, 1000);
        -> 2
mysql> select INTERVAL(22, 23, 30, 44, 200);
        -> 0

    7.3.6 Fonctions de comparaisons des chaînes

    Dans une expression quelconque, si une des chaînes est sensible à la casse, alors la comparaison tiendra compte de la casse.

  • expr1 LIKE expr2 [ESCAPE 'escape-char'] Expression régulière SQL. Retourne 1 (TRUE) ou 0 (FALSE). Avec LIKE, les caractères spéciaux suivants sont disponibles : 
    mysql> select 'David!' LIKE 'David_';
        -> 1
mysql> select 'David!' LIKE '%D%v%';
        -> 1

    Pour tester la présence d'un des caractères spéciaux, il suffit de faire précéder du caractère d'échappement. Si ce dernier n'est pas précisé, le caractère ``\'' est alors utilisé. 

    mysql> select 'David!' LIKE 'David\_';
        -> 0
mysql> select 'David_' LIKE 'David\_';
        -> 1

    Pour spécifier un autre caractère d'échappement, il faut utiliser la clause ESCAPE : 

    mysql> select 'David_' LIKE 'David|_' ESCAPE '|';
       -> 1

    LIKE peut travailler avec des expressions numériques (c'est une extension de la norme ANSI SQL.) 

    mysql> select 10 LIKE '1%';
        -> 1

    Note: Comme MySQL utilise le système d'échappement du langage C (e.g., ``\n''), il faut doubler toutes les occurrences dans les clause LIKE. Par exemple, pour rechercher le caractère ``\n'', il faut mettre la chaîne ``\\n''. Pour recherche le caractère for ``\'', il faut l'écrire ``\\\\'' (les backslashes sont supprimés une première fois par l'analyseur syntaxique, et une deuxième fois, quand la recherche est terminée : ce qui laisse un seul backslash à rechercher).

  • expr1 NOT LIKE expr2 [ESCAPE 'escape-char'] Identique à NOT (expr1 LIKE expr2 [ESCAPE 'escape-char']).
  • expr REGEXP pat
  • expr RLIKE pat
  • expression REGEXP pat
  • expression RLIKE pat Effectue une chercher sur la chaîne expression avec le masque pat. Le pattern peut être une expression régulière étendue. Retoune 1 si l'expression régulière réussit, 0. RLIKE est un synonyme pour REGEXP, fourni pour assurer la compatibilité avec mSQL Note: Comme MySQL utilise le système d'échappement du langage C (e.g., ``\n''), il faut doubler toutes les occurrences dans les clause. REGEXP . 
    
mysql> select 'Monty!' REGEXP 'm%y%%';
        -> 0
mysql> select 'Monty!' REGEXP '.*';
        -> 1
mysql> select 'new*\n*line' REGEXP 'new\\*.\\*line';
        -> 1

    REGEXP et RLIKE utilisent le jeu de caractère (ISO-8859-1 Latin1 par défaut) pour choisir le type de caractère.

  • expr NOT REGEXP pat
  • expr NOT RLIKE pat
  • expression NOT REGEXP expression Identique à NOT (expression REGEXP expression ).
  • STRCMP(expr1,expr2) STRCMP() retourne 0 si les chaînes sont identiques, -1 si le premier argument est plus petit que le second, en fonction de l'ordre de tri courant, et sinon 1 . 
    mysql> select STRCMP('text', 'text2');
        -> -1
mysql> select STRCMP('text2', 'text');
        -> 1
mysql> select STRCMP('text', 'text');
        -> 0

    7.3.7 Opérateurs de transtypage

  • BINARY L'opérateur BINARY transforme la chaîne qui le suive en chaîne insensible à la casse. C'est un moyen simple de forcer une comparaison insensible à la casse, même si la colonne n'a pas été définie comme un BINARY ou BLOB. 
    mysql> select "a" = "A";
        -> 1
mysql> select BINARY "a" = "A";
        -> 0

    BINARY a été introduit dans MySQL 3.23.0

    7.3.8 Fonctions de contrôle

  • IFNULL(expr1,expr2) Si expr1 n'est pas NULL, IFNULL() retourne expr1, sinon expr2. IFNULL() retourne un nombre ou une chaîne, en fonction du contexte dans lequel il est utilisé. 
    mysql> select IFNULL(1,0);
        -> 1
mysql> select IFNULL(0,10);
        -> 0
mysql> select IFNULL(1/0,10);
        -> 10
mysql> select IFNULL(1/0,'yes');
        -> 'yes'
  • IF(expr1,expr2,expr3) Si expr1 est vraie (TRUE) (expr1 <> 0 et expr1 <> NULL) alors IF() retourne expr2, sinon il retourne expr3. IF() retourne un nombre ou une chaîne, en fonction du contexte dans lequel il est utilisé. 
    mysql> select IF(1>2,2,3);
        -> 3
mysql> select IF(1<2,'yes','no');
        -> 'yes'
mysql> select IF(strcmp('test','test1'),'yes','no');
        -> 'no'

    expr1 est évaluée en tant qu'entier, ce qui signifie que si le test portait sur un nombre à virgule flottante ou une chaîne, il faudrait mieux utiliser un opérateur de comparaison. 

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

    Dans le premier cas ci-dessus, IF(0.1) retourne 0 car 0.1 est converti en un nombre entier, ce qui conduit à un test de type IF(0). C'est une source d'erreur. Dans le deuxième cas, la comparaison est faite avec un opérateur de comparaison, qui teste la non nullité. Le résultat de la comparaison est utilisé comme un entier.

  • CASE value WHEN [compare-value] THEN result [WHEN [compare-value] THEN result ...] [ELSE result] END
  • CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result] END La première version retourne result si value=compare-value. La seconde version retourne le résultat si la première condition est vraie. Si il n'y a aucun résultat, alors, le résultat après ELSE est retourné. SI il n'y a pas de résultat pour ELSE alors NULL. 
    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

    7.3.9 Fonctions mathématiques

    Toutes les fonctions mathématiques retourne NULL en cas d'erreur.

  • - Moins unaire. Change le signe de l'argument. 
    mysql> select - 2;
        -> -2

    Note : si cet opérateur est utilisé avec un BIGINT, le résultat sera BIGINT! Cela signifie qu'il faut éviter d'utiliser – sur des entiers qui ont la valeur -2^63!

  • ABS(X) Valeur absolue de X. 
    mysql> select ABS(2);
        -> 2
mysql> select ABS(-32);
        -> 32

    Cette fonction ne pose aucun problème particulier avec les valeurs de type BIGINT.

  • SIGN(X) Retourne le signe de l'argument sous la forme -1, 0 or 1, suivant que X est négatif, nul, ou positif. 
    mysql> select SIGN(-32);
        -> -1
mysql> select SIGN(0);
        -> 0
mysql> select SIGN(234);
        -> 1
  • MOD(N,M)
  • % Modulo (identique à l'opérateur % en langage C). Retourne le reste de la division euclidienne de N par M. 
    mysql> select MOD(234, 10);
        -> 4
mysql> select 253 % 7;
        -> 1
mysql> select MOD(29,9);
        -> 2

    Cette fonction ne pose aucun problème particulier avec les valeurs de type BIGINT.

  • FLOOR(X) Retourne le plus grand entier possible mais plus petit que X. 
    mysql> select FLOOR(1.23);
        -> 1
mysql> select FLOOR(-1.23);
        -> -2

    Note : le résultat est converti en BIGINT!

  • CEILING(X) Retourne le plus petit entier possible mais plus grand que X. 
    mysql> select CEILING(1.23);
        -> 2
mysql> select CEILING(-1.23);
        -> -1

    Note : le résultat est converti en BIGINT!

  • ROUND(X) Retourne l'argument X, arrondi à l'entier le plus proche. 
    mysql> select ROUND(-1.23);
        -> -1
mysql> select ROUND(-1.58);
        -> -2
mysql> select ROUND(1.58);
        -> 2

    Note : le résultat est converti en BIGINT!

  • ROUND(X,D) Retourne l'argument X, arrondi au décimal le plus proche, avec D décimales. Si D =0, le résultat n'aura pas de partie décimale. 
    mysql> select ROUND(1.298, 1);
        -> 1.3
mysql> select ROUND(1.298, 0);
        -> 1

    Note : le résultat est converti en BIGINT!

  • EXP(X) Retourne la valeur de e (base des logarithmes naturels ou népériens) à la puissance X. 
    mysql> select EXP(2);
        -> 7.389056
mysql> select EXP(-2);
        -> 0.135335
  • LOG(X) Retourne le logarithme naturel de X. 
    mysql> select LOG(2);
        -> 0.693147
mysql> select LOG(-2);
        -> NULL

    Pour obtenir la valeur du logarithme de X dans une base arbitraire, il faut utiliser la formule LOG(X)/LOG(B).

  • LOG10(X) Retourne le logarithme de X en base 10. 
    mysql> select LOG10(2);
        -> 0.301030
mysql> select LOG10(100);
        -> 2.000000
mysql> select LOG10(-100);
        -> NULL
  • POW(X,Y)
  • POWER(X,Y) Retourne la valeur de X à la puissance Y. 
    mysql> select POW(2,2);
        -> 4.000000
mysql> select POW(2,-2);
        -> 0.250000
  • SQRT(X) Retourne la racine carrée positive de X. 
    mysql> select SQRT(4);
        -> 2.000000
mysql> select SQRT(20);
        -> 4.472136
  • PI() Retourne la valeur de PI. 
    mysql> select PI();
        -> 3.141593
  • COS(X) Retourne le cosinus de X, avec X en radians. 
    
mysql> select COS(PI());
        -> -1.000000
  • SIN(X) Retourne le sinus de X, avec X en radians. 
    mysql> select SIN(PI());
        -> 0.000000
  • TAN(X) Retourne la tangente de X, avec X en radians. 
    mysql> select TAN(PI()+1);
        -> 1.557408
  • ACOS(X) Retourne l'arcosinus de X, c'est à dire l'angle dont le cosinus est X en radians. Retourne NULL si X n'est pas compris entre -1 et 1. 
    mysql> select ACOS(1);
        -> 0.000000
mysql> select ACOS(1.0001);
        -> NULL
mysql> select ACOS(0);
        -> 1.570796
  • ASIN(X) Retourne l'arsinus de X, c'est à dire l'angle dont le sinus est X en radians. Retourne NULL si X n'est pas compris entre -1 et 1. 
    mysql> select ASIN(0.2);
        -> 0.201358
mysql> select ASIN('foo');
        -> 0.000000
  • ATAN(X) Retourne l'arctangente de X, c'est à dire l'angle dont la tangente est X en radians. 
    mysql> select ATAN(2);
        -> 1.107149
mysql> select ATAN(-2);
        -> -1.107149
  • ATAN2(X,Y) Retourne l'arc tangente de deux variables X et Y. C'est le même calcul que arc tangent of Y / X, hormis le fait que les signes des deux arguments est utilisé pour déterminer le quadrant du résultat. 
    mysql> select ATAN(-2,2);
        -> -0.785398
mysql> select ATAN(PI(),0);
        -> 1.570796
  • COT(X) Retourne la cotangente de X. 
    mysql> select COT(12);
        -> -1.57267341
mysql> select COT(0);
        -> NULL
  • RAND()
  • RAND(N) Retourne un nombre aléatoire, compris entre 0 et 1.0. Si un entier N est précisé, il est utilisé comme valeur de seed. 
    mysql> select RAND();
        -> 0.5925
mysql> select RAND(20);
        -> 0.1811
mysql> select RAND(20);
        -> 0.1811
mysql> select RAND();
        -> 0.2079
mysql> select RAND();
        -> 0.7888

    Il est impossible d'utiliser une colonne de valeur RAND() avec la clause ORDER BY , car la colonne sera évalué plusieurs fois. Avec MySQL 3.23, il est cependant possible d'écrire: SELECT * FROM Nom_table ORDER BY RAND(). Comme cela, il est possible de faire une sélection aléatoire d'une table : SELECT * FROM table1,table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000.

  • LEAST(X,Y,...) Au moins deux arguments, retourne la plus petite valeur (minimum). Les arguments sont comparés en utilisant les règles suivantes :
      • Si LEAST est utilisé dans un contexte d'entiers, ou bien tous les arguments sont des entiers, les arguments sont évalués et comparés en tant qu'entiers.
      • Si LEAST est utilisé dans un contexte de nombre à virgule flottante, les arguments sont évalués et comparés en tant que nombre à virgule flottante.
      • Si tous les arguments sont des chaînes sensibles à la casse, tous les arguments sont comparés comme des chaînes insensibles à la casse.
      • Dans tous les autres cas, les arguments sont comparés comme des chaînes insensibles à la casse. 
    mysql> select LEAST(2,0);
        -> 0
mysql> select LEAST(34.0,3.0,5.0,767.0);
        -> 3.0
mysql> select LEAST("B","A","C");
        -> "A"

    Avec les version de MySQL antérieur à la 3.22.5, il est possible d'utiliser MIN() à la place de LEAST.

  • GREATEST(X,Y,...) Retourne le plus grand argument de la liste. Les arguments sont comparés de la même manière que pour LEAST. 
    mysql> select GREATEST(2,0);
        -> 2
mysql> select GREATEST(34.0,3.0,5.0,767.0);
        -> 767.0
mysql> select GREATEST("B","A","C");
        -> "C"

    Avec les version de MySQL antérieur à la 3.22.5, il est possible d'utiliser MAX () à la place de GREATEST.

  • DEGREES(X) Retourne l'argument X, converti de radians en degrés. 
    mysql> select DEGREES(PI());
        -> 180.000000
  • RADIANS(X) Retourne l'argument X, converti de radians degrés en radians. 
    mysql> select RADIANS(90);
        -> 1.570796
  • TRUNCATE(X,D) Retourne l'argument X, tronqué à D décimales. 
    mysql> select TRUNCATE(1.223,1);
        -> 1.2
mysql> select TRUNCATE(1.999,1);
        -> 1.9
mysql> select TRUNCATE(1.999,0);
        -> 1

    7.3.10 Fonctions de chaînes

    Les fonctions qui retourne des chaînes, retourneront NULL si le résultat dépasse la taille maximale de max_allowed_packet.

    Pour les opérations sur les chaînes, le premier caractère est en position 1.

  • ASCII(str) Retourne le code ASCII du premier caractère de la chaîne. Si la chaîne est vide, retourne 0. Si la chaîne est NULL, retourne NULL. 
    mysql> select ASCII('2');
        -> 50
mysql> select ASCII(2);
        -> 50
mysql> select ASCII('dx');
        -> 100
  • CONV(N,from_base,to_base) Converti des nombres d'une base à l'autre, et retourne la chaîne représentant le résultat converti. Si la chaîne est NULL, retourne NULL. L'argument N est considéré comme un entier, mais peut être un entier ou une chaîne. La base minimum est 2, et maximum est 36. Si la base d'arrivée est un nombre négatif, N est considéré comme un entier signé. Sinon, N est traité comme un entiers non signé. CONV fonctionne à la précision 64 bits. 
    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'
  • BIN(N) Retourne une chaîne représentant l'argument N en binaire. N est un BIGINT. Cette fonction est l'équivalent de CONV(N,10,2). Retourne NULL si N est NULL. 
    mysql> select BIN(12);
        -> '1100'
  • OCT(N) Retourne une chaîne représentant l'argument N en base 8. N est un BIGINT. Cette fonction est l'équivalent de CONV(N,10,8). Retourne NULL si N est NULL. 
    mysql> select OCT(12);
        -> '14'
  • HEX(N) Retourne une chaîne représentant l'argument N en hexadécimal. N est un BIGINT. Cette fonction est l'équivalent de CONV(N,10,16). Retourne NULL si N est NULL. 
    mysql> select HEX(255);
        -> 'FF'
  • CHAR(N,...) Interprète les arguments comme des nombres entiers, et retourne une chaîne constituée des caractères correspondant aux codes ASCII des arguments. Les valeurs NULL sont ignorées. 
    mysql> select CHAR(77,121,83,81,'76');
        -> 'MySQL'
mysql> select CHAR(77,77.3,'77.3');
        -> 'MMM'
  • CONCAT(X,Y,...) Concatène les arguments, et re tourne le résultat. Retourne NULL si un des arguments est NULL. Le nombre d'argument minimum est 2. 
    mysql> select CONCAT('My', 'S', 'QL');
        -> 'MySQL'
mysql> select CONCAT('My', NULL, 'QL');
        -> NULL
  • LONGUEUR(str)
  • OCTET_LONGUEUR(str)
  • CHAR_LONGUEUR(str)
  • CHARACTER_LONGUEUR(str) Retourne la longueur de la chaîne str. 
    mysql> select LONGUEUR('text');
        -> 4
mysql> select OCTET_LONGUEUR('text');
        -> 4
  • LOCATE(substr,str)
  • POSITION(substr IN str) Retourne la position de la première occurrence de substr dans la chaîne. Retourne 0 si substr n'est pas trouvée. 
    mysql> select LOCATE('bar', 'foobarbar');
        -> 4
mysql> select LOCATE('xbar', 'foobar');
        -> 0
  • LOCATE(substr,str,pos) Retourne la position de la première occurrence de substr dans la chaîne, en commencant à chercher à partir de la position pos. Retourne 0 si substr n'est pas trouvée. 
    mysql> select LOCATE('bar', 'foobarbar',5);
        -> 7
  • INSTR(str,substr) Retourne la position de la première occurrence de substr dans la chaîne, en commencant à chercher à partir de la position pos. Retourne 0 si substr n'est pas trouvée. C'est la même fonction que LOCATE(), mais les deux arguments n'ont pas la même place. 
    mysql> select INSTR('foobarbar', 'bar');
        -> 4
mysql> select INSTR('xbar', 'foobar');
        -> 0
  • LPAD(str,len,padstr) Retourne la chaîne str, complétée à gauche par la chaîne padstr jusqu'à ce que le résultat ait la longueur . 
    mysql> select LPAD('hi',4,'??');
        -> '??hi'
  • RPAD(str,len,padstr) Retourne la chaîne str, complétée à droite par la chaîne padstr jusqu'à ce que le résultat ait la longueur . 
    mysql> select RPAD('hi',5,'?');
        -> 'hi???'
  • LEFT(str,len) Retourne les len premiers caractères de la chaîne str. 
    mysql> select LEFT('foobarbar', 5);
        -> 'fooba'
  • RIGHT(str,len)
  • SUBSTRING(str FROM len) Retourne les len derniers caractères de la chaîne str. 
    mysql> select RIGHT('foobarbar', 4);
        -> 'rbar'
mysql> select SUBSTRING('foobarbar' FROM 4);
        -> 'rbar'
  • SUBSTRING(str,pos,len)
  • SUBSTRING(str FROM pos FOR len)
  • MID(str,pos,len) Retourne les len caractères de la chaîne str, en commencant à partir de la position pos. La variante FROM est une syntaxe issue de la norme ANSI SQL92. 
    mysql> select SUBSTRING('Quadratically',5,6);
        -> 'ratica'
  • SUBSTRING(str,pos) Retourne une sous-chaîne, issue de str et commencant à la position pos. 
    mysql> select SUBSTRING('Quadratically',5);
        -> 'ratically'
  • SUBSTRING_INDEX(str,delim,count) Retourne une sous-chaîne, issue de str, après count occurrences du délimiteur delim. Si count est positif, la sous-chaîne comprendra tous les caractères situés à gauche du délimiteur final. Si count est négatif, la sous-chaîne comprendra tous les caractères situés à droite du délimiteur final 
    mysql> select SUBSTRING_INDEX('www.mysql.com', '.', 2);
        -> 'www.mysql'
mysql> select SUBSTRING_INDEX('www.mysql.com', '.', -2);
        -> 'mysql.com'
  • LTRIM(str) Retourne la chaîne str après élimination des espaces situés en début de chaîne. 
    mysql> select LTRIM('  barbar');
        -> 'barbar'
  • RTRIM(str) retourne la chaîne str après élimination des espaces situés en fin de chaîne. 
    mysql> select RTRIM('barbar   ');
        -> 'barbar'
  • TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str) Retourne la chaîne str après élimination de chaînes remstr situées en début et/ou fin de chaîne. Si aucune des options BOTH, LEADING ou TRAILING n'est précisé, alors BOTH est utilisé par défaut. Si remstr n'est pas précisé, les espaces sont éliminés. 
    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'
  • SOUNDEX(str) Retourne une représentation phonétique de la chaîne . Deux chaînes qui " sonne de la même façon " devraient avoir des représentation identiques. Une représentation standard a 4 caractères, mais SOUNDEX() retourne un nombre arbitraire de caractère. Il faudra alors utiliser SUBSTRING() sur le résultat pour avoir une représentation standard. Les caractères non-alphanumériques sont ignorés. Tous les caractères alphabétiques hors de l'intervalle A-Z sont considéré comme des voyelles.
  • Attention : cette fonction ayant été programmé par des anglophones, la " sonorité " d'une chaîne aura un fort accent anglais. 
    
mysql> select SOUNDEX('Hello');
        -> 'H400'
mysql> select SOUNDEX('Quadratically');
        -> 'Q36324'
  • SPACE(N) Crée une chaîne contenant N espaces. 
    mysql> select SPACE(6);
        -> '      '
  • REPLACE(str,from_str,to_str) Remplace les occurrences de from_str par la chaîne to_str, dans la chaîne str. 
    mysql> select REPLACE('www.mysql.com', 'w', 'Ww');
        -> 'WwWwww.mysql.com'
  • REPEAT(str,count) Retourne une chaîne constituée des répétitions de la chaîne . Si count <= 0, retourne une chaîne vide. Si str ou count est NULL, retourne NULL. 
    mysql> select REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'
  • REVERSE(str) Inverse l'ordre des caractères de la chaîne str. 
    mysql> select REVERSE('abc');
        -> 'cba'
  • INSERT(str,pos,len,newstr) Retourne la chaîne str, avec la chaîne newstr qui remplace tous les caractères à partir de la position pos, et sur la longueur len. 
    mysql> select INSERT('Quadratic', 3, 4, 'What');
        -> 'QuWhattic'
  • ELT(N,str1,str2,str3,...) Retourne str1 si N = 1, str2 si N = 2, etc... Retourne NULL si est plus petit que 1 ou plus grand que le nombre d'arguments. ELT() est le contraire de FIELD(). 
    mysql> select ELT(1, 'ej', 'Heja', 'hej', 'foo');
        -> 'ej'
mysql> select ELT(4, 'ej', 'Heja', 'hej', 'foo');
        -> 'foo'
  • FIELD(str,str1,str2,str3,...) Retourne l'index de la chaîne str dans la liste des arguments . Retourne 0 si str n'est pas trouvé .FIELD() est le contraire de ELT() 
    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 l'index de la chaîne dans la liste. Une liste de chaîne est composée de chaînes, séparées par le caractère ``,''. Si le premier argument est une chaîne constante, et le deuxième est une colonne de type SET, la fonction est optimisée FIND_IN_SET() pour utiliser l'arithmétique sur les bits ! Retourne str si n'est pas dans la liste strlist, ou si la liste est vide. Retourne NULL si l'un des arguments est NULL. La fonction n'accepte pas de caractère ``,''dans le premier membre de la liste. 
    mysql> SELECT FIND_IN_SET('b','a,b,c,d');
        -> 2
  • MAKE_SET(bits,str1,str2,...) Retourne un ensemble (une chaîne contenant des sous-chaînes séparée par ``,'') qui correspond à u sous-ensemble des chaînes en arguments. La chaîne à l'index i sera présente dans l'ensemble résultat, si le bit à l'index i est à un, dans bits). 
    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');
        -> ''
  • EXPORT_SET(bits,on,off,[separator],[number_of_bits]) Retourne une chaîne dans laquelle, pour chaque bit à 1 , il y a la chaîne on, pour chaque bit à 0 , il y a la chaîne off, séparés par le separator (par défaut, ','), et uniquement pour les number_of_bits (par défaut, 64) premiers bits. 
    mysql> select EXPORT_SET(5,'Y','N',',',4)
        -> Y,N,Y,N
  • LCASE(str)
  • LOWER(str) Retourne la chaîne avec tous les caractères en minuscules, conformément au jeu de caractère courant (par défaut, ISO-8859-1 Latin1). 
    mysql> select LCASE('QUADRATICALLY');
        -> 'quadratically'
  • UCASE(str)
  • UPPER(str) Retourne la chaîne avec tous les caractères en majuscule, conformément au jeu de caractère courant (par défaut, ISO-8859-1 Latin1). 
    mysql> select UCASE('Hej');
        -> 'HEJ'
  • LOAD_FILE(Nom_fichier) Lit le fichier Nom_fichier et retourne le résultat dans une chaîne. Le fichier doit être sur le serveur, et il faut préciser le nom et le chemin d'accès complet. Le fichier doit être lisible par tous, et être plus petit que max_allowed_packet. Si le fichier n'existe pas, ou ne peut être lu, la fonction retourne NULL. 
    mysql> UPDATE Nom_tableSET blob_column=LOAD_FILE("/tmp/picture") WHERE id=1;

    Il n'y a pas de fonction de conversion d'un nombre en char. Il n'y en pas besoin, car MySQL converti automatiquement les nombres en chaînes, et vice versa. 

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

    Si une fonction qui travaille sur des chaînes sensibles à la casse recoit comme argument une chaîne insensible à la casse, le resultat sera aussi une chaîne insensible à la casse. Un nombre converti en chaîne est traité comme une chaîne insensible à la casse. Cela n'affecte que les comparaisons.

    7.3.11 Fonctions de date et heure

    7.2.6 Types date et heure pour une description précise des intervalles de validité de chaque type.

    Voici un exemple qui utilise des fonctions sur les dates et heures. La requête ci-dessous sélectionne toutes les lignes avec une valeur qui est date_col dans les 30 derniers jours : 

    mysql> SELECT quelquechose FROM table
           WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;
  • DAYOFWEEK(date) Retourne le jour de la semaine sous la forme d'un index qui commence à 1 (1 = Dimanche, 2 = Lundi, ... 7 = Samedi). Ces valeurs sont celles du standard ODBC. 
    mysql> select DAYOFWEEK('1998-02-03');
        -> 3
  • WEEKDAY(date) Retourne le jour de la semaine sous la forme d'un index qui commence à 0 (0 = Dimanche, 1 = Lundi, ... 6 = Samedi). 
    mysql> select WEEKDAY('1997-10-04 22:23:00');
        -> 5
mysql> select WEEKDAY('1997-11-05');
        -> 2
  • DAYOFMONTH(date) Retourne le jour du mois sous la forme d'un index entre 1 et 31. 
    mysql> select DAYOFMONTH('1998-02-03');
        -> 3
  • DAYOFYEAR(date) Retourne le jour de l'année sous la forme d'un index entre 1 et 366. 
    mysql> select DAYOFYEAR('1998-02-03');
        -> 34
  • MONTH(date) Retourne le mois de la date sous la forme d'un index entre 1 et 12. 
    mysql> select MONTH('1998-02-03');
        -> 2
  • DAYNAME(date) Retourne le nom du jour de la date sous la forme d'une chaîne (en anglais ). 
    mysql> select DAYNAME("1998-02-05");
        -> 'Thursday'
  • MONTHNAME(date) Retourne le nom du mois de la date sous la forme d'une chaîne (en anglais ). 
    mysql> select MONTHNAME("1998-02-05");
        -> 'February'
  • QUARTER(date) Retourne le trimestre de la date sous la forme d'un index entre 1 et 4. 
    mysql> select QUARTER('98-04-01');
        -> 2
  • WEEK(date)
  • WEEK(date,first) Avec un seul argument, retourne la semaine de la date sous la forme d'un index entre 1 à 52, avec Dimanche comme premier jour de la semaine. La fonction avec deux arguments permet de préciser si la semaine commence à Dimanche (0) ou Lundi (1). 
    mysql> select WEEK('1998-02-20');
        -> 7
mysql> select WEEK('1998-02-20',0);
        -> 7
mysql> select WEEK('1998-02-20',1);
        -> 8
  • YEAR(date) Retourne l'année de la date sous la forme d'un index entre 1000 et 9999. 
    mysql> select YEAR('98-02-03');
        -> 1998
  • HOUR(time) Retourne l'heure de la date sous la forme d'un index entre 0 et 23. 
    mysql> select HOUR('10:05:03');
        -> 10
  • MINUTE(time) Retourne la minute de la date sous la forme d'un index entre 0 et 59. 
    mysql> select MINUTE('98-02-03 10:05:03');
        -> 5
  • SECOND(time) Retourne la seconde de la date sous la forme d'un index entre 0 et 59. 
    mysql> select SECOND('10:05:03');
        -> 3
  • PERIOD_ADD(P,N) Ajoute N mois à la date P (au format YYMM ou YYYYMM). Retourne le résultat au format YYYYMM. Il faut bien noter que la date P n'est pas au format date. 
    mysql> select PERIOD_ADD(9801,2);
        -> 199803
  • PERIOD_DIFF(P1,P2) Retourne le nombre de mois entre deux dates P1 et P2. P1 et P2 doivent être au format . Il faut bien noter que les dates P1 et P2 ne sont pas au format date. 
    mysql> select PERIOD_DIFF(9802,199703);
        -> 11

  • DATE_ADD(date,INTERVAL expression type)
  • DATE_SUB(date,INTERVAL expression type)
  • ADDDATE(date,INTERVAL expression type)
  • SUBDATE(date,INTERVAL expression type) Ces fonctions effectuent des opérations arithmétiques sur les dates. Elles ont été inserées dans MySQL 3.22. ADDDATE() et SUBDATE() sont synonymes de DATE_ADD() et DATE_SUB(). date est de type DATETIME ou DATE , qui indique la date de début. expression est une expression qui donne une durée à ajouter ou à retrancher à la date de début. expression est une chaîne qui peut commencer par un signe moins (``-''), pour indiquer une durée négative. type est un mot clé qui indique comment l'expression doit être considéré. La table suivante établit la relation type et expression :
    type value Meaning Expected expr format
    SECOND Seconds SECONDS
    MINUTE Minutes MINUTES
    HOUR Hours HOURS
    DAY Days DAYS
    MONTH Months MONTHS
    YEAR Years YEARS
    MINUTE_SECOND Minutes and seconds "MINUTES:SECONDS"
    HOUR_MINUTE Hours and minutes "HOURS:MINUTES"
    DAY_HOUR Days and hours "DAYS HOURS"
    YEAR_MONTH Years and months "YEARS-MONTHS"
    HOUR_SECOND Hours, minutes, "HOURS:MINUTES:SECONDS"
    DAY_MINUTE Days, hours, minutes "DAYS HOURS:MINUTES"
    DAY_SECOND Days, hours, minutes, seconds "DAYS HOURS:MINUTES:SECONDS"
    MySQL allows any non-numeric delimiter in the expr format. The ones shown in the table are the suggested delimiters. If the date argument is a DATE value and your calculations involve only YEAR, MONTH and DAY parts (that is, no time parts), the result is a DATE value. Otherwise the result is a DATETIME value. 
    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 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 accepte l'utilisation de délimiteurs non-numériques dans le format de expression . Ceux présentés dans le tableaux ne sont que des suggestions. Si l'argument date est au format DATE et que les calculs font intervenir seulement YEAR, MONTH et DAY (c'est à dire, juste la date, par l'heure.), le résultat est de type DATE . Sinon, le résultat des de type DATETIME . 
    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

    Si l'argument de durée est trop court par rapport au mot clé spécifié, MySQL suppose que les parties de gauche sont mises à zéro. Par exemple, avec le mot clé DAY_SECOND , s'attend à trouver le format "JOURS HEURES:MINUTES:SECONDES" . Si l'argument de durée est "1:10", supposera que les jours et heures sont à 0, et que seules, les minutes et secondes sont fournies. En un sens, MySQL ignore le type spécifié, et utilise à la place MINUTE_SECOND. Si les dates sont incorrectes, le résultat est NULL. Par ailleurs, lors de l'utilisation des options MONTH, YEAR_MONTH ou YEAR, et que dans le mois résultant, la date du jours n'existe pas, elle est automatiquement ramenée à la plus grande valeur qu'elle peut prendre dans ce mois. 

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

    Note from the preceding example that the word INTERVAL and the type keyword are not case sensitive.

  • TO_DAYS(date) Retourne l'index du jour par rapport au 1er janvier 0. 
    mysql> select TO_DAYS(950501);
        -> 728779
mysql> select TO_DAYS('1997-10-07');
        -> 729669

    TO_DAYS() n'est pas prévu pour utiliser des dates précédents l'avènement du calendrier Grégorien. (1582)..

  • FROM_DAYS(N) Etant donné un numéro de jour par rapport au 1er janvier 0, retourne une valeur de type DATE. 
    mysql> select FROM_DAYS(729669);
        -> '1997-10-07'

    FROM_DAYS()n'est pas prévu pour utiliser des dates précédents l'avènement du calendrier Grégorien. (1582).

  • DATE_FORMAT(date,format) Formate la date date en fonction de la chaîne format. Les formats suivants peuvent être utilisé dans format :
    %M Month name (January..December)
    %W Weekday name (Sunday..Saturday)
    %D Day of the month with english suffix (1st, 2nd, 3rd, etc.)
    %Y Year, numeric, 4 digits
    %y Year, numeric, 2 digits
    %a Abbreviated weekday name (Sun..Sat)
    %d Day of the month, numeric (00..31)
    %e Day of the month, numeric (0..31)
    %m Month, numeric (01..12)
    %c Month, numeric (1..12)
    %b Abbreviated month name (Jan..Dec)
    %j Day of year (001..366)
    %H Hour (00..23)
    %k Hour (0..23)
    %h Hour (01..12)
    %I Hour (01..12)
    %l Hour (1..12)
    %i Minutes, numeric (00..59)
    %r Time, 12-hour (hh:mm:ss [AP]M)
    %T Time, 24-hour (hh:mm:ss)
    %S Seconds (00..59)
    %s Seconds (00..59)
    %p AM or PM
    %w Day of the week (0=Sunday..6=Saturday)
    %U Week (0..52), where Sunday is the first day of the week
    %u Week (0..52), where Monday is the first day of the week
    %% A literal `%'.
    Tous les autres caractères sont recopiés, sans interpretation 
    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'

    Depuis MySQL 3.23, le caractère % est obligatoire devant le caractère de format. Dans les versions antérieures de MySQL, % il était optionnel.

  • TIME_FORMAT(time,format) Utilisation identique à DATE_FORMAT(), mais seulement pour les heures (heures, minutes secondes). Les autres arguments conduisent à un résultat a NULL ou 0.
  • CURDATE()
  • CURRENT_DATE Retourne la date du jour, au format 'YYYY-MM-DD' ou YYYYMMDD , suivant que la fonction est utilisée en contexte chaîne ou numérique 
    mysql> select CURDATE();
        -> '1997-12-15'
mysql> select CURDATE() + 0;
        -> 19971215
  • CURTIME()
  • CURRENT_TIME Retourne l'heure du jour, au format 'HH:MM:SS' or HHMMSS, suivant que la fonction est utilisée en contexte chaîne ou numérique 
    mysql> select CURTIME();
        -> '23:50:26'
mysql> select CURTIME() + 0;
        -> 235026
  • NOW()
  • SYSDATE()
  • CURRENT_TIMESTAMP Retourne la date et l'heure du jour, au format 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS, suivant que la fonction est utilisée en contexte chaîne ou numérique 
    mysql> select NOW();
        -> '1997-12-15 23:50:26'
mysql> select NOW() + 0;
        -> 19971215235026
  • UNIX_TIMESTAMP()
  • UNIX_TIMESTAMP(date) Utilisé sans argument, retourne un timestamp Unix (le nombre de secondes depuis '1970-01-01 00:00:00' GMT) . Utilisé avec un argument de type date, il renvoie le timestamp Unix correspondant à cette date. DATE peut être aux formats chaîne DATE chaîne, DATETIME chaîne, TIMESTAMP, ou un nombre au format YYMMDD ou YYYYMMDD. 
    mysql> select UNIX_TIMESTAMP();
        -> 882226357
mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00');
        -> 875996580

    Quand un UNIX_TIMESTAMP est affecté à une colonne de type TIMESTAMP, l'affectation sera directe, avec aucune conversion implicite.

  • FROM_UNIXTIME(unix_timestamp) Retourne la représentation de l'argument unix_timestamp au format 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS suivant que la fonction est utilisée en contexte chaîne ou numérique 
    mysql> select FROM_UNIXTIME(875996580);
        -> '1997-10-04 22:23:00'
mysql> select FROM_UNIXTIME(875996580) + 0;
        -> 19971004222300
  • FROM_UNIXTIME(unix_timestamp,format) Retourne la représentation de l'argument unix_timestamp au format format, suivant que la fonction est utilisée en contexte chaîne ou numérique. Le format est spécifié comme pour la fonction the DATE_FORMAT(). 
    mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),
                            '%Y %D %M %h:%i:%s %x');
        -> '1997 23rd December 03:43:30 x'
  • SEC_TO_TIME(seconds) Converti l'argument seconds en heures, minutes et secondes, au format 'HH:MM:SS' or HHMMSS, suivant que la fonction est utilisée en contexte chaîne ou numérique 
    mysql> select SEC_TO_TIME(2378);
        -> '00:39:38'
mysql> select SEC_TO_TIME(2378) + 0;
        -> 3938
  • TIME_TO_SEC(time) Retourne l'argument time, converti en secondes. 
    mysql> select TIME_TO_SEC('22:23:00');
        -> 80580
mysql> select TIME_TO_SEC('00:39:38');
        -> 2378

    7.3.12 Fonctions diverses

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    7.3.13 Fonctions à utiliser dans les clauses GROUP BY

    L'utilisation d'une fonction de regroupement dans une commande qui ne contient pas la clause GROUP BY est équivalent à regrouper toutes les lignes.

  • COUNT(expression ) Retourne le nombre de lignes non-NULL obtenue par une commande SELECT. 
    mysql> select student.student_name,COUNT(*)
           from student,course
           where student.student_id=course.student_id
           GROUP BY student_name;

    COUNT(*) est optimisé pour compter très rapidement les lignes obtenues par un SELECT sur une seule table, sans qu'aucune autre colonne ne soit demandée, et sans clause WHERE . Par exemple : 

    mysql> select COUNT(*) from student;
  • COUNT(DISTINCT expression ,[expression ...]) Retourne le nombre de ligne distinctes. 
    mysql> select COUNT(DISTINCT results) from student;

    Avec MySQL il est possible d'obtenir le nombre de combinaison d'expressions distinctes en donnant une liste d'expression. E, ANSI SQL, il aurait fallu concaténer les expressions avec CODE(DISTINCT ..).

  • AVG(expression ) Retourne la moyenne des valeurs de expression . 
    mysql> select student_name, AVG(test_score)
           from student
           GROUP BY student_name;
  • MIN(expression )
  • MAX(expression ) Retourne le minimum ou le maximum de expression . MIN() et MAX() peuvent travailler avec des chaînes. Dans ce cas, il retourne la chaîne minimum maximum . 
    mysql> select student_name, MIN(test_score), MAX(test_score)
           from student
           GROUP BY student_name;
  • SUM(expression ) Retourne la somme de expression . Si l'ensemble n'a aucune ligne, le résultat est NULL!
  • STD(expression )
  • STDDEV(expression ) Retourne la déviation standard de expression . C'est une extension à la norme ANSI SQL. La fonction STDDEV() est fourni pour assurer la comptabilité avec les bases Oracle.
  • BIT_OR(expression ) Retourne le OU logique bit-à-bit, effectué sur expression . Ce calcul est fait sur 64 bits (précision de BIGINT).
  • BIT_AND(expression ) Retourne le ET logique bit-à-bit, effectué sur expression . Ce calcul est fait sur 64 bits (précision de BIGINT).

    MySQL permet une utilisation étendue de GROUP BY. Il est possible de faire des calculs sur des colonnes dans le SELECT même si elles n'apparaissent pas dans le GROUP BY . Cela est possible pour n'importe quelle valeur de ce groupe. Cela permet de gagner en performance en évitant de faire des regroupements ou des tris sur des valeurs inutiles. Par exemple, il n'y a pas besoin de faire un regroupement avec customer.name dans la requête suivante : 

    mysql> select order.custid,customer.name,max(payments)
       from order,customer
       where order.custid = customer.custid
       GROUP BY order.custid;

    La norme ANSI SQL impose d'ajouter customer.name dans la clause GROUP BY . Avec MySQL, c'est redondant.

    Il ne faut pas utiliser cette particularité si les noms de colonnes ne sont pas unique dans le groupe courant.

    Dans certains cas, il est possible d'utiliser MIN() et MAX() pour obtenir la valeur d'une colonne spécifique, même si elle n'est pas unique. Par exemple, cette requête retourne la valeur de column, de la ligne qui contient la colonne sort la plus courte. 

    substr(MIN(concat(sort,space(6-longueur(sort)),column),7,longueur(column)))

    Il faut noter que avec MySQL 3.22 (ou avant), ou en suivant la norme ANSI SQL, il ne faut pas utiliser d'expressions dans les clauses GROUP BY ou ORDER BY. Il faut alors contourner la difficulté en utilisant un alias. 

    mysql> SELECT id,FLOOR(value/100) AS val FROM Nom_table
           GROUP BY id,val ORDER BY val;

    Avec MySQL 3.23, on peut écrire : 

    mysql> SELECT id,FLOOR(value/100) FROM Nom_table ORDER BY RAND();