Chapitre 12 Fonctions à utiliser dans les clauses SELECT et WHERE

( ... )

Utilisez les parenthèses pour forcer l'ordre des évaluations dans une expression. Par exemple :

mysql> SELECT 1+2*3;
        -> 7
mysql> SELECT (1+2)*3;
        -> 9

Si l'un ou les deux arguments sont NULL, le résultat de la comparaison est NULL, exception faite pour l'opérateur <=>.

Si les deux arguments de la comparaison sont des chaînes, ils seront comparés en tant que chaînes.

Si les deux arguments sont des entiers, ils sont comparés en tant qu'entiers.

Les valeurs hexadécimales sont traitées en tant que chaînes binaires si elles ne sont pas comparées à un nombre.

Si l'un des arguments est une colonne de type TIMESTAMP ou DATETIME et que l'autre est une constante, celle ci est convertie en timestamp avant que la comparaison ne s'opère. Cela est fait pour être mieux compatible avec ODBC.

Dans tous les autres cas, les arguments sont comparés en tant que nombres à décimale flottante. (réels)

=

Egal :

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

<=>

Comparaison compatible avec NULL. Cet opérateur fait une comparaison d'égalité comme l'opérateur =, mais retourne 1 plutôt que NULL si les deux opérandes sont NULL, et 0 plutôt que NULL si un opérande est NULL.

mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
        -> 1, 1, 0
mysql> SELECT 1 = 1, NULL = NULL, 1 = NULL;
        -> 1, NULL, NULL

<=> a été ajouté en MySQL 3.23.0.

<>, != Différent :

mysql> SELECT '.01' <> '0.01';
        -> 1
mysql> SELECT .01 <> '0.01';
        -> 0
mysql> SELECT 'zapp' <> 'zappp';
        -> 1

<=

Inférieur ou égal :

mysql> SELECT 0.1 <= 2;
        -> 1

<

Strictement inférieur :

mysql> SELECT 2 < 2;
        -> 0

>=

Supérieur ou égal :

mysql> SELECT 2 >= 2;
        -> 1

>

Strictement supérieur :

mysql> SELECT 2 > 2;
        -> 0

IS NULL, IS NOT NULL

Tester si une valeur est ou n'est pas NULL:

mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
        -> 0 0 1
mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
        -> 1 1 0

Pour être compatible avec les autres programmes, MySQL gère les appels qui utilisent IS NULL de la fa¸on suivante :

expression BETWEEN min AND max

Si expression est supérieure ou égale à min et expression est inférieure ou égale à max, BETWEEN retourne 1, sinon 0. Ceci est équivalent à l'expression (min <= expression AND expression <= max) si tous les arguments sont du même type. Dans tous les autres cas, la conversion de type prends place, selon les règles suivantes, mais appliquée aux trois arguments. Notez que avant la 4.0.5, les arguments étaient convertis au type de expr.

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

expr NOT BETWEEN min AND max

Même chose que NOT (expr BETWEEN min AND max).

COALESCE(list)

Retourne le premier élément non-NULL de la liste :

mysql> SELECT COALESCE(NULL,1);
        -> 1
mysql> SELECT COALESCE(NULL,NULL,NULL);
        -> NULL

GREATEST(value1,value2,...)

Avec deux ou plusieurs arguments, retourne la valeur la plus grande. Les arguments sont comparés en utilisant les mêmes règles 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'

Avant MySQL 3.22.5, vous pouvez utiliser MAX() au lieu de GREATEST().

expr IN (valeur,...)

Retourne 1 si expr est l'une des valeurs dans la liste IN, sinon retourne 0. Si toutes les valeurs sont des constantes, toutes les valeurs sont évaluées avec le type de expr et triées. La recherche de l'élément est alors faite en utilisant la recherche binaire. Cela signifie que IN est très rapide si les valeurs contenues dans la liste IN sont toutes des constantes. Si expr est une chaîne sensible à la casse, la comparaison est faite dans un contexte sensible à la casse :

mysql> SELECT 2 IN (0,3,5,'wefwf');
        -> 0
mysql> SELECT 'wefwf' IN (0,3,5,'wefwf');
        -> 1

Depuis MySQL version 4.1, une clause IN() peut aussi contenir une sous-requête. See Section 13.1.8.3, « Sous-requêtes avec les clauses ANY, IN et SOME ».

expr NOT IN (value,...)

Même chose que NOT (expr IN (valeur,...)).

ISNULL(expr)

Si expr est NULL, ISNULL() retourne 1, sinon il retourne 0:

mysql> SELECT ISNULL(1+1);
        -> 0
mysql> SELECT ISNULL(1/0);
        -> 1

Notez que la comparaison de deux valeurs NULL en utilisant = donnera toujours false !

INTERVAL(N,N1,N2,N3,...)

Retourne 0 si N < N1, 1 si N < N2 etc... Tous les arguments sont traités en tant qu'entiers. Il est requis que N1 < N2 < N3 < ... < Nn pour que cette fonction fonctionne correctement. Cela est due à la recherche binaire utilisée (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

LEAST(value1,value2,...)

Avec deux arguments ou plus, retourne la plus petite valeur. Les arguments sont comparés avec les règles suivantes :

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'

Avant MySQL 3.22.5, vous pouvez utiliser MIN() au lieu de LEAST().

Notez que les conversions précédentes peuvent produire des résultats étranges dans certains cas limites :

mysql> SELECT CAST(LEAST(3600, 9223372036854775808.0) as SIGNED);
        -> -9223372036854775808

Cela arrive parce que MySQL lit 9223372036854775808.0 dans un contexte d'entier. La représentation entière n'est pas suffisante pour contenir la valeur, alors elle est transformée en entier signé.

NOT, !

NOT (NON) logique. Evalue à 1 si l'opérande est 0, à 0 si l'opérande est non nulle, et NOT NULL retourne NULL.

mysql> SELECT NOT 10;
        -> 0
mysql> SELECT NOT 0;
        -> 1
mysql> SELECT NOT NULL;
        -> NULL
mysql> SELECT ! (1+1);
        -> 0
mysql> SELECT ! 1+1;
        -> 1

Le dernier exemple donne 1 car l'expression est évaluée comme (!1)+1.

AND, &&

AND (ET) logique. Evalue à 1 si toutes les opérandes sont différentes de zéro et de NULL, à 0 si l'une des opérandes est 0, dans les autres cas, NULL est retourné.

mysql> SELECT 1 && 1;
        -> 1
mysql> SELECT 1 && 0;
        -> 0
mysql> SELECT 1 && NULL;
        -> NULL
mysql> SELECT 0 && NULL;
        -> 0
mysql> SELECT NULL && 0;
        -> 0

Notez que pour les versions antérieures à la 4.0.5 l'évaluation est interrompue lorsque NULL est rencontré, au lieu de continuer à tester une éventuelle existence de 0. Cela signifie que dans ces versions, SELECT (NULL AND 0) retourne NULL au lieu de 0. En 4.0.5 le code a été revu pour que le résultat réponde toujours au normes ANSI tout en optimisant le plus possible.

OR, ||

OR (OU inclusif) logique. Evalue à 1 si aucune opérande n'est nulle, à NULL si l'une des opérandes est NULL, sinon 0 est retourné.

mysql> SELECT 1 || 1;
        -> 1
mysql> SELECT 1 || 0;
        -> 1
mysql> SELECT 0 || 0;
        -> 0
mysql> SELECT 0 || NULL;
        -> NULL
mysql> SELECT 1 || NULL;
        -> 1

XOR

XOR (OU exclusif) logique. Retourne NULL si l'une des opérandes est NULL. Pour les opérandes non-NULL, évalue à 1 si un nombre pair d'opérandes est non-nul, sinon 0 est retourné.

mysql> SELECT 1 XOR 1;
        -> 0
mysql> SELECT 1 XOR 0;
        -> 1
mysql> SELECT 1 XOR NULL;
        -> NULL
mysql> SELECT 1 XOR 1 XOR 1;
        -> 1

a XOR b est mathématiquement égal à (a AND (NOT b)) OR ((NOT a) and b).

expr LIKE pat [ESCAPE 'escape-char']

La réalisation d'expression utilisant les expressions régulières simples de comparaison de SQL. Retourne 1 (TRUE) ou 0 (FALSE). Avec LIKE, vous pouvez utiliser les deux jokers suivants :

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

Pour tester la présence littérale d'un joker, précédez-le d'un caractère d'échappement. Si vous ne spécifiez pas le caractère d'échappement ESCAPE, le caractère ‘\’ sera utilisé :

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

Pour spécifier un caractère d'échappement différent, utilisez la clause ESCAPE :

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

Les deux exemples suivants illustrent le fait que les comparaisons de chaînes de caractères ne sont pas sensibles à la casse à moins qu'une des opérandes soit une chaîne binaire.

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

LIKE est également autorisé pour les expressions numériques. (C'est une extension MySQL à la norme ANSI SQL LIKE.)

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

Note : Comme MySQL utilise la syntaxe d'échappement de caractères du langage C dans les chaînes (par exemple, ‘\n’), vous devez doubler tous les slash ‘\’ que vous utilisez dans les expressions LIKE. Par exemple, pour rechercher les nouvelles lignes (‘\n’), vous devez le spécifier comme cela : ‘\\n’. Pour rechercher un anti-slash (‘\’), vous devez le spécifier comme cela : ‘\\\\’ (les anti-slash sont supprimés une première fois pas l'analyseur syntaxique, puis une deuxième fois par le moteur d'expression régulières, ce qui ne laisse qu'un seul anti-slash à la fin).

Note : actuellement, LIKE n'est pas compatible avec les caractères multi-octets. La comparaison est faîte caractère par caractère.

expr NOT LIKE pat [ESCAPE 'escape-char']

Equivalent à NOT (expr LIKE pat [ESCAPE 'escape-char']).

expr NOT REGEXP pat, expr NOT RLIKE pat

Equivalent à NOT (expr REGEXP pat).

expr REGEXP pat, expr RLIKE pat

Effectue une recherche de chaîne avec l'expression régulière pat. Le masque peut être une expression régulière étendue. Voir la section Annexe F, Expressions régulières MySQL. Retourne 1 si expr correspond au masque pat, sinon, retourne 0. RLIKE est un synonyme de REGEXP, fourni pour assurer la compatibilité avec mSQL. Note : Comme MySQL utilise la syntaxe d'échappement de caractères du langage C dans les chaînes (par exemple, ‘\n’), vous devez doubler tous les anti-slash ‘\’ que vous utilisez dans les expressions REGEXP. A partir de la version 3.23.4 de MySQL, REGEXP est insensible à la casse pour les comparaisons de chaînes normales (non binaires) :

mysql> SELECT 'Monty!' REGEXP 'm%y%%';
        -> 0
mysql> SELECT 'Monty!' REGEXP '.*';
        -> 1
mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
        -> 1
mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';
        -> 1  0
mysql> SELECT 'a' REGEXP '^[a-d]';
        -> 1

STRCMP(expr1,expr2)

STRCMP() retourne 0 si les chaînes sont identiques, -1 si la première chaîne est plus petite que la seconde et 1 dans les autres cas :

mysql> SELECT STRCMP('text', 'text2');
        -> -1
mysql> SELECT STRCMP('text2', 'text');
        -> 1
mysql> SELECT STRCMP('text', 'text');
        -> 0

Depuis MySQL 4.0, STRCMP() utilise le jeu de caractères courant pour effectuer des comparaisons. Cela fait que le comportement par défaut est la comparaison insensible à la casse, à moins que l'un des deux opérandes soient une chaîne binaire. Avant MySQL 4.0, STRCMP() était sensible à la casse.

+

Addition :

mysql> SELECT 3+5;
        -> 8

-

Soustraction :

mysql> SELECT 3-5;
        -> -2

-

Moins unaire. Change le signe de l'argument.

mysql> SELECT - 2;
        -> -2

Notez que si cet opérateur est utilisé avec un BIGINT, la valeur retournée est un BIGINT! Cela signifie que vous devez éviter d'utiliser - sur des entiers qui peuvent avoir une valeur de -2^63!

*

Multiplication :

mysql> SELECT 3*5;
        -> 15
mysql> SELECT 18014398509481984*18014398509481984.0;
        -> 324518553658426726783156020576256.0
mysql> SELECT 18014398509481984*18014398509481984;
        -> 0

Le résultat du dernier calcul est incorrect car le résultat de la multiplication des deux entiers à dépassé la capacité de calcul de BIGINT (64 bits).

/

Division :

mysql> SELECT 3/5;
        -> 0.60

La division par zéro produit un résultat NULL :

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

Une division sera calculée en BIGINT seulement si elle est effectuée dans un contexte où le résultat est transformé en entier.

DIV

Division entière. Similaire à FLOOR() mais compatible avec les valeurs BIGINT.

mysql> SELECT 5 DIV 2;
        -> 2

DIV a été ajouté en MySQL 4.1.0.

ABS(X)

Retourne la valeur absolue de X.

mysql> SELECT ABS(2);
        -> 2
mysql> SELECT ABS(-32);
        -> 32

Cette fonction est utilisable avec les valeurs issues des champs BIGINT.

ACOS(X)

Retourne l'arccosinus de X, c'est à dire, la valeur de l'angle dont X est la cosinus. Retourne NULL si X n'est pas dans l'intervalle -1 - 1.

mysql> SELECT ACOS(1);
        -> 0.000000
mysql> SELECT ACOS(1.0001);
        -> NULL
mysql> SELECT ACOS(0);
        -> 1.570796

ASIN(X)

Retourne l'arcsinus de X, c'est à dire, la valeur de l'angle dont le sinus est X. Retourne NULL si X n'est pas dans l'intervalle -1 - 1 :

mysql> SELECT ASIN(0.2);
        -> 0.201358
mysql> SELECT ASIN('foo');
        -> 0.000000

ATAN(X)

Retourne l'arctangente de X, c'est à dire, la valeur de l'angle dont la tangente est X.

mysql> SELECT ATAN(2);
        -> 1.107149
mysql> SELECT ATAN(-2);
        -> -1.107149

ATAN(Y,X), ATAN2(Y,X)

Retourne l'arctangente des variables X et Y. Cela revient à calculer l'arctangente de Y / X, excepté que les signes des deux arguments servent à déterminer le quadrant du résultat :

mysql> SELECT ATAN(-2,2);
        -> -0.785398
mysql> SELECT ATAN2(PI(),0);
        -> 1.570796

CEILING(X), CEIL(X)

Retourne la valeur entière supérieure de X.

mysql> SELECT CEILING(1.23);
        -> 2
mysql> SELECT CEILING(-1.23);
        -> -1

Notez que la valeur retournée sera de type BIGINT!

COS(X)

Retourne le cosinus de X, où X est donné en radians.

mysql> SELECT COS(PI());
        -> -1.000000

COT(X)

Retourne la cotangente de X.

mysql> SELECT COT(12);
        -> -1.57267341
mysql> SELECT COT(0);
        -> NULL

CRC32(expr)

Calcule la somme de contrôle et retourne un entier 32 bits non-signé. Le résultat est la valeur NULL si l'argument est NULL. L'argument attendu est une chaîne, et sera traité comme une chaîne s'il n'est pas du bon type.

mysql> SELECT CRC32('MySQL');
        -> 3259397556

CRC32() est disponible en MySQL 4.1.0.

DEGREES(X)

Retourne l'argument X, convertit de radians en degrés.

mysql> SELECT DEGREES(PI());
        -> 180.000000

EXP(X)

Retourne la valeur de e (la base des logarithmes naturels) élevé à la puissance X.

mysql> SELECT EXP(2);
        -> 7.389056
mysql> SELECT EXP(-2);
        -> 0.135335

FLOOR(X)

Retourne la valeur entière inférieure de X.

mysql> SELECT FLOOR(1.23);
        -> 1
mysql> SELECT FLOOR(-1.23);
        -> -2

Notez que la valeur retournée sera de type BIGINT!

LN(X)

Retourne le logarithme naturel de X (népérien).

mysql> SELECT LN(2);
        -> 0.693147
mysql> SELECT LN(-2);
        -> NULL

Cette fonction a été ajoutée à MySQL à partir de la version 4.0.3. C'est un synonyme de la fonction LOG(X).

LOG(X), LOG(B,X)

Appelée avec un seul paramètre, cette fonction retourne le logarithme naturel (népérien) de X.

mysql> SELECT LOG(2);
        -> 0.693147
mysql> SELECT LOG(-2);
        -> NULL

Appelée avec deux paramètres, cette fonction retourne le logarithme naturel de X pour une base B arbitraire :

mysql> SELECT LOG(2,65536);
        -> 16.000000
mysql> SELECT LOG(1,100);
        -> NULL

Cette base arbitraire a été ajoutée à MySQL à partir de la version 4.0.3. LOG(B,X) est l'équivalent de LOG(X)/LOG(B).

LOG2(X)

Retourne le logarithme en base 2 de X.

mysql> SELECT LOG2(65536);
        -> 16.000000
mysql> SELECT LOG2(-100);
        -> NULL

LOG2() est utile pour trouver combien de bits sont nécessaires pour stocker un nombre. Cette fonction a été ajoutée à MySQL à partir de la version 4.0.3. Dans les versions antérieures, vous pouvez utiliser LOG(X)/LOG(2) en remplacement.

LOG10(X)

Retourne le logarithme en base 10 de X.

mysql> SELECT LOG10(2);
        -> 0.301030
mysql> SELECT LOG10(100);
        -> 2.000000
mysql> SELECT LOG10(-100);
        -> NULL

MOD(N,M), N % M, N MOD M

Modulo (équivalent de l'opérateur % dans le langage C). Retourne le reste de la division 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 pas de problèmes avec les BIGINT.

PI()

Retourne la valeur de pi. Par défaut, 5 décimales sont retournées, mais MySQL utilise la double précision pour pi.

mysql> SELECT PI();
        -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
        -> 3.141592653589793116

POW(X,Y), POWER(X,Y)

Retourne la valeur de X élevée à la puissance Y :

mysql> SELECT POW(2,2);
        -> 4.000000
mysql> SELECT POW(2,-2);
        -> 0.250000

RADIANS(X)

Retourne l'argument X, converti de degrés en radians.

mysql> SELECT RADIANS(90);
        -> 1.570796

RAND(), RAND(N)

Retourne un nombre aléatoire à virgule flottante compris dans l'intervalle 0 - 1.0. Si l'argument entier N est spécifié, il est utilisé comme initialisation du générateur de nombres aléatoires.

mysql> SELECT RAND();
        -> 0.9233482386203
mysql> SELECT RAND(20);
        -> 0.15888261251047
mysql> SELECT RAND(20);
        -> 0.15888261251047
mysql> SELECT RAND();
        -> 0.63553050033332
mysql> SELECT RAND();
        -> 0.70100469486881

Vous ne pouvez pas utiliser une colonne de valeur RAND() dans une clause ORDER BY, parce que ORDER BY va évaluer la colonne plusieurs fois. Dans la version 3.23 de MySQL, vous pouvez, tout de même, faire ceci :

mysql> SELECT * FROM tbl_name ORDER BY RAND();

Cette syntaxe est très pratique pour faire une sélection aléatoire de lignes :

mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d
    -> ORDER BY RAND() LIMIT 1000;

Notez que la fonction RAND() dans une clause WHERE sera réévaluée à chaque fois que WHERE sera exécuté.

RAND() n'est pas un générateur parfait de nombres aléatoires, mais reste une manière rapide de produire des nombres aléatoires portables selon les différentes plates-formes pour une même version de MySQL.

ROUND(X), ROUND(X,D)

Retourne l'argument X, arrondi à un nombre à D décimales. Avec deux arguments, la valeur est arrondie avec D décimales.

Si D vaut 0, le résultat n'aura ni de partie décimale, ni de séparateur de décimal.

mysql> SELECT ROUND(-1.23);
        -> -1
mysql> SELECT ROUND(-1.58);
        -> -2
mysql> SELECT ROUND(1.58);
        -> 2
mysql> SELECT ROUND(1.298, 1);
        -> 1.3
mysql> SELECT ROUND(1.298, 0);
        -> 1
mysql> SELECT ROUND(23.298, -1);
        -> 20

Notez que le comportement de l'opérateur ROUND(), lorsque l'argument est exactement entre deux entiers, dépend de la bibliothèque C active. Certaines arrondissent toujours à l'entier pair le plus proche, toujours vers le haut, toujours vers le bas, ou toujours vers zéro. Si vous avez besoin d'un certain type d'arrondissement, vous devez utiliser une fonction bien définie comme TRUNCATE() ou FLOOR().

SIGN(X)

Retourne le signe de l'argument sous la forme -1, 0, ou 1, selon que X est négatif, zéro, ou positif.

mysql> SELECT SIGN(-32);
        -> -1
mysql> SELECT SIGN(0);
        -> 0
mysql> SELECT SIGN(234);
        -> 1

SIN(X)

Retourne le sinus de X, où X est donné en radians.

mysql> SELECT SIN(PI());
        -> 0.000000

SQRT(X)

Retourne la racine carrée de X.

mysql> SELECT SQRT(4);
        -> 2.000000
mysql> SELECT SQRT(20);
        -> 4.472136

TAN(X)

Retourne la tangente de X, où X est donné en radians.

mysql> SELECT TAN(PI()+1);
        -> 1.557408

TRUNCATE(X,D)

Retourne l'argument X, tronqué à D décimales. Si D vaut 0, le résultat n'aura ni séparateur décimal, ni partie décimale.

mysql> SELECT TRUNCATE(1.223,1);
        -> 1.2
mysql> SELECT TRUNCATE(1.999,1);
        -> 1.9
mysql> SELECT TRUNCATE(1.999,0);
        -> 1
mysql> SELECT TRUNCATE(-1.999,1);
        -> -1.9

A partir de MySQL 3.23.51 tous les nombres sont arrondis vers zéro.

Notez que les nombres décimaux ne sont pas stockés exactement comme les nombres entiers , mais comme des valeurs doubles. Vous pouvez être dupés par le résultat suivant :

mysql> SELECT TRUNCATE(10.28*100,0);
       -> 1027

Ce résultat est normal car 10.28 est actuellement stocké comme cela 10.2799999999999999.

Elle n'utilise pas le seuil de 50%.

Elles ne trie pas automatiquement les lignes par ordre de pertinence décroissante. Vous pouvez le voir dans l'exemple précédent : la ligne ayant la plus grande pertinence est celle qui contient ``MySQL'' deux fois, mais elle est listée en dernier.

Elles peuvent fonctionner sans l'index FULLTEXT, même si c'est particulièrement lent.

+

A signe + initial indique que le mot doit être présent dans la ligne retournée.

-

Un signe - initial indique que le mot ne doit pas être présent dans la ligne retournée.

(pas d'opérateur)

Par défaut, lorsque ni +, ni - n'est spécifié), le mot est optionnel, mais les lignes qui le contiennent seront mieux cotées. Cela imite le comportement de MATCH() ... AGAINST() sans l'option IN BOOLEAN MODE.

> <

Ces deux opérateurs servent à changer la contribution d'un mot à la pertinence. L'opérateur > accroît la contribution, et l'opérateur < la décroît. Voir un exemple ci-dessous.

( )

Les parenthèses servent à grouper des mots en sous-expressions. Les groupes de parenthèses peuvent être imbriquées.

~

Un signe tilde initial marque la négation, et fait que la contribution du mot à la pertinence sera négative. Cet opérateur est pratique pour marquer les mots ambigus. Une ligne qui contient un tel mot sera classée bien plus bas, mais elle ne sera pas exclue, comme ce serait le cas avec -.

*

Un astérisque est l'opérateur de troncature. Contrairement aux autres opérateurs, il doit être en suffixe et non pas en préfixe.

"

Une phrase entre guillemets double (‘"’) est recherchée littéralement, telle qu'elle a été saisie.

'pomme banane'

Recherche les lignes qui contiennent au moins un de ces mots.

'+pomme +jus'

Recherche les lignes qui contiennent ces deux mots.

'+pomme macintosh'

Recherche les lignes qui contiennent le mot ``pomme'', mais classe plus haut les lignes qui contiennent aussi ``macintosh''.

'+pomme -macintosh'

Recherche les lignes qui contiennent ``pomme'' mais pas ``macintosh''.

'+pomme +(>tatin <strudel)'

Recherche les lignes qui contiennent les mots ``pomme'' et ``tatin'', ou ``pomme'' et ``strudel'' (dans n'importe quel ordre), mais classe ``pomme tatin'' plus haut que ``pomme strudel''.

'pomm*'

Trouve les lignes qui contiennent des mots tels que ``pomme'', ``pommes'', ``pommier'', ou ``pommeau''.

'"deux mots"'

Recherche les lignes qui contiennent exactement la phrase ``deux mots'' (par exemple, les lignes qui contiennent ``deux mots d'amour'' mais pas ``le mot deux''). Notez que les caractères ‘"’ qui entourent la phrase délimitent la phrase. Ils ne délimitent pas la chaîne.

La recherche en texte intégral n'est supportée que par les tables MyISAM.

Depuis MySQL 4.1.1, les recherches en texte plein peuvent être utilisées avec la plupart des jeux de caractères. L'exception est pour Unicode, le jeu de caractères utf8 peut être utilisé, mais pas ucs2.

Depuis MySQL 4.1, l'utilisation de jeux de caractères multiples dans une table est supportée. Cependant, toutes les colonnes dans un index FULLTEXT doivent avoir le même jeu de caractères et collation.

Les arguments de MATCH() doivent correspondre exactement à la liste de colonnes de certaines définitions d'index FULLTEXT pour la table, sauf si MATCH() est utilisé dans un contexte BOOLEAN.

L'argument de AGAINST() doit être une chaîne constante.

La taille minimale des mots à indexer est définie dans la variable ft_min_word_len de MySQL. See Section 13.5.3.18, « Syntaxe de SHOW VARIABLES ». Vous pouvez modifier cette valeur pour celle que vous préférez, puis reconstruire les index FULLTEXT. (Cette variable n'existe que pour la version 4.0 de MySQL) La valeur par défaut de cette option est de 4 caractères. Modifiez la, puis recompilez les index FULLTEXT. Par exemple, si vous souhaitez pouvoir rechercher des mots de 3 caractères, vous pouvez donner à cette variable la valeur suivante dans le fichier d'options :

[mysqld]
ft_min_word_len=3

Puis, relancez le serveur et recompilez vos index FULLTEXT.

La liste des mots rejetés est définie dans la variable ft_stopword_file. See Section 13.5.3.18, « Syntaxe de SHOW VARIABLES ». Modifiez le selon vos goûts, reconstruisez vos index FULLTEXT.

Le taux de 50% est déterminé par la méthode de pondération choisie. Pour le désactiver, il faut changer la ligne suivante dans myisam/ftdefs.h :

#define GWS_IN_USE GWS_PROB

Par la ligne:

#define GWS_IN_USE GWS_FREQ

Puis recompiler MySQL. Il n'est pas nécessaire de reconstruire les index dans ce cas. Note : en faisant ces modifications, vous diminuez énormément les capacités de MySQL à fournir des valeurs pertinentes pour la fonction MATCH(). Si vous avez réellement besoin de faire des recherches avec ces mots courants, il est préférable de rechercher EN MODE BOOLEEN, lequel ne respecte pas le taux de 50%.

Pour changer les opérateurs utilisés pour les recherches booléennes, modifiez la variable système ft_boolean_syntax (disponible depuis MySQL 4.0.1). La variable peut aussi être modifiée durant le fonctionnement du serveur, mais vous devez avoir les droits de SUPER. La recompilation des index n'est pas possible. Section 5.2.3, « Variables serveur système » décrit les règles de définition de cette variable.

Rendre toutes les opérations avec l'index FULLTEXT plus rapides.

Opérateurs de proximité

Support de listes de mots à toujours indexer ("always-index words"). Ceux ci pourraient être n'importe quelle chaîne de caractères que l'utilisateur voudrais traiter comme des mots : par exemple "C++", "AS/400", "TCP/IP", etc.

Support de la recherche full-text sur les tables MERGE.

Support des jeux de caractères multi-octets.

Rendre la liste des mots ignorés dépendante de la langue des données.

Stemming (dépendante de la langue des données, bien sûr).

Preprocesseur générique pour les UDF fournies par l'utilisateur.

Rendre le modèle plus flexible (en ajoutant des valeurs paramétrables pour FULLTEXT dans CREATE/ALTER TABLE).

|

OU bit-à-bit (OR)

mysql> SELECT 29 | 15;
        -> 31

Le résultat est un entier de 64 bits non signé.

&

ET bit-à-bit (AND)

mysql> SELECT 29 & 15;
        -> 13

Le résultat est un entier de 64 bits non signé.

^

XOR bit-à-bit

mysql> SELECT 1 ^ 1;
        -> 0
mysql> SELECT 1 ^ 0;
        -> 1
mysql> SELECT 11 ^ 3;
        -> 8

Le résultat est un entier de 64 bits non signé.

<<

Décale les bits de l'entier (BIGINT) sur la gauche :

mysql> SELECT 1 << 2;
        -> 4

Le résultat est un entier de 64 bits non signé.

>>

Décale les bits de l'entier (BIGINT) sur la droite :

mysql> SELECT 4 >> 2;
        -> 1

Le résultat est un entier de 64 bits non signé.

~

Inverse tous les bits :

mysql> SELECT 5 & ~1;
        -> 4

Le résultat est un entier de 64 bits non signé.

BIT_COUNT(N)

Retourne le nombre de bits non nuls de l'argument N :

mysql> SELECT BIT_COUNT(29);
        -> 4

AES_ENCRYPT(str,key_str), AES_DECRYPT(crypt_str,key_str)

Ces fonctions permettent le chiffrement/déchiffrement de données utilisant l'algorithme AES (Advanced Encryption Standard), anciennement connu sous le nom de Rijndael. Une clé de 128 bits est utilisé pour le chiffrement, mais vous pouvez l'étendre à 256 bits en modifiant les sources. Nous avons choisi 128 bits parce que c'est plus rapide et suffisamment sécurisé.

Les arguments peuvent être de n'importe quelle taille. Si l'un des arguments est NULL, le résultat de cette fonction sera NULL.

Vu que AES est un algorithme de niveau bloc, le capitonnage est utilisé pour chiffrer des chaînes de longueur inégales et donc, la longueur de la chaîne résultante peut être calculée comme ceci : 16*(trunc(string_length/16)+1).

Si la fonction AES_DECRYPT() détecte des données invalides ou un capitonnage incorrect, elle retournera NULL. Il est également possible que la fonction AES_DECRYPT() retourne une valeur différente de NULL (valeur incohérente) si l'entrée de données ou la clé est invalide.

Vous pouvez utiliser les fonctions AES pour stocker des données sous une forme chiffrée en modifiant vos requêtes:

INSERT INTO t VALUES (1,AES_ENCRYPT("text","password"));

Vous pouvez obtenir encore plus de sécurité en évitant de transférer la clé pour chaque requête, en la stockant dans une variable sur le serveur au moment de la connexion :

SELECT @password:="my password";
INSERT INTO t VALUES (1,AES_ENCRYPT("text",@password));

Les fonctions AES_ENCRYPT() et AES_DECRYPT() ont été ajoutées dans la version 4.0.2 de MySQL et peuvent être considérées comme étant les fonctions de cryptographie les plus sûres disponibles actuellement dans MySQL.

DECODE(crypt_str,pass_str)

Déchiffre la chaîne chiffrée crypt_str en utilisant la clé pass_str. crypt_str doit être une chaîne qui a été renvoyée par la fonction ENCODE().

ENCODE(str,pass_str)

Chiffre la chaîne str en utilisant la clé pass_str. Pour déchiffrer le résultat, utilisez la fonction DECODE().

Le résultat est une chaîne binaire de la même longueur que string. Si vous voulez sauvegarder le résultat dans une colonne, utilisez une colonne de type BLOB.

DES_DECRYPT(crypt_str[,key_str])

Déchiffre une chaîne chiffrée à l'aide de la fonction DES_ENCRYPT().

Notez que cette fonction fonctionne uniquement si vous avez configuré MySQL avec le support SSL. See Section 5.6.7, « Utilisation des connexions sécurisées ».

Si l'argument key_string n'est pas donné, la fonction DES_DECRYPT() examine le premier bit de la chaîne chiffrée pour déterminer le numéro de clé DES utilisé pour chiffrer la chaîne originale, alors la clé est lu dans le fichier des-key-file pour déchiffrer le message. Pour pouvoir utiliser cela, l'utilisateur doit avoir le privilège SUPER.

Si vous passé l'argument key_string à cette fonction, cette chaîne est utilisée comme clé pour déchiffrer le message.

Si la chaîne string_to_decrypt ne semble pas être une chaîne chiffrée, MySQL retournera la chaîne string_to_decrypt.

Si une erreur survient, cette fonction retourne NULL.

DES_ENCRYPT(str[,(key_num|key_str)])

Chiffre la chaîne avec la clé donnée en utilisant l'algorithme DES.

Notez que cette fonction fonctionne uniquement si vous avez configuré MySQL avec le support SSL. See Section 5.6.7, « Utilisation des connexions sécurisées ».

La clé de hachage utilisée est choisie en suivant les recommandations suivantes :

La chaîne retournée doit être une chaîne binaire où le premier caractère doit être CHAR(128 | key_number).

Le nombre 128 a été ajouté pour reconnaître facilement une clé de hachage. Si vous utilisez une chaîne comme clé, key_number doit être 127.

Si une erreur survient, la fonction retournera NULL.

La longueur de la chaîne de résultat doit être : new_length= org_length + (8-(org_length % 8))+1.

des-key-file a le format suivant :

key_number des_key_string
key_number des_key_string

Chaque key_number doit être un nombre dans l'intervalle 0 à 9. Les lignes dans le fichier peuvent être dans n'importe quel ordre. des_key_string est la chaîne qui permettra le chiffrage du message. Entre le nombre et la clé, il doit y avoir au moins un espace. La première clé est la clé par défaut qui sera utilisé si vous ne spécifiez pas d'autres clés en arguments de la fonction DES_ENCRYPT().

Vous pouvez demander à MySQL de lire de nouvelles valeurs de clé dans le fichier de clés avec la commande FLUSH DES_KEY_FILE. Cela requière le privilège Reload_priv.

Un des bénéfices d'avoir une liste de clés par défaut est que cela donne aux applications la possibilité de regarder l'existence de la valeur chiffrée de la colonne, sans pour autant donner la possibilité à l'utilisateur final de déchiffrer ces valeurs.

mysql> SELECT customer_address FROM customer_table WHERE
       crypted_credit_card = DES_ENCRYPT("credit_card_number");

ENCRYPT(str[,salt])

Chiffre la chaîne str en utilisant la fonction crypt(). L'argument salt doit être une chaîne de deux caractères. (A partir de la version 3.22.16, l'argument salt peut être plus long que deux caractères.) :

mysql> SELECT ENCRYPT("hello");
        -> 'VxuFAJXVARROc'

Si la fonction crypt() n'est pas disponible sur votre système, la fonction ENCRYPT() retournera toujours NULL.

La fonction ENCRYPT() conserve uniquement les 8 premiers caractères de la chaîne str, au moins, sur certains système. Le comportement exact est directement déterminé par la fonction système crypt() sous-jacente.

MD5(str)

Calcul la somme de vérification MD5 de la chaîne string. La valeur retournée est un entier hexadécimal de 32 caractères qui peut être utilisé, par exemple, comme clé de hachage :

mysql> SELECT MD5("testing");
        -> 'ae2b1fca515949e5d54fb22b8ed95575'

C'est l'algorithme RSA ("RSA Data Security, Inc. MD5 Message-Digest Algorithm").

OLD_PASSWORD(str)

OLD_PASSWORD() est disponible depuis MySQL 4.1, lorsque l'implémentation de la fonction PASSWORD() a été modifiée pour améliorer la sécurité. OLD_PASSWORD() retourne la valeur pre-4.1 de PASSWORD(). Section 5.5.9, « Hashage de mots de passe en MySQL 4.1 ».

PASSWORD(str)

Calcule un mot de passe chiffré à partir de la chaîne str. C'est cette fonction qui est utilisé pour chiffrer les mots de passes MySQL pour être stockés dans une colonne de type Password de la table user :

mysql> SELECT PASSWORD('badpwd');
        -> '7f84554057dd964b'

Le chiffrage par PASSWORD() n'est pas réversible.

PASSWORD() n'est pas un chiffrage comparable à la fonction de chiffrage Unix. Voir ENCRYPT().

Note : La fonction PASSWORD() est utilisée durant l'identification au serveur MYSQL. Il est recommandé de ne pas l'utiliser pour vos applications. Utilisez plutôt MD5() ou SHA1(). Voyez aussi RFC-2195 pour plus d'informations sur comment gérer les mots de passe et l'identification de votre système.

SHA1(str), SHA(str)

Calcule la somme de vérification SHA1 160 bits de la chaîne string, comme décrit dans la RFC 3174 (Secure Hash Algorithm). La valeur retournée est un entier hexadécimal de 40 caractères, ou bien NULL dans le cas où l'argument vaut NULL. Une des possibilités d'utilisation de cette fonction est le hachage de clé. Vous pouvez aussi l'utilisé comme fonction de cryptographie sûre pour stocker les mots de passe.

mysql> SELECT SHA1("abc");
        -> 'a9993e364706816aba3e25717850c26c9cd0d89d'

La fonction SHA1() a été ajoutée dans la version 4.0.2 de MySQL et peut être considérée comme une méthode de cryptographie plus sûre que la fonction MD5(). La fonction SHA() est un alias de la fonction SHA1().

BENCHMARK(count,expr)

La fonction BENCHMARK() exécute l'expression expr de manière répétée count fois. Elle permet de tester la vélocité de MySQL lors du traitement d'une requête. Le résultat est toujours 0. L'objectif de cette fonction ne se voit que du côté client, qui permet à ce dernier d'afficher la durée d'exécution de la requête :

mysql> SELECT BENCHMARK(1000000,ENCODE("bonjour","au revoir"));
+--------------------------------------------------+
| BENCHMARK(1000000,ENCODE("bonjour","au revoir")) |
+--------------------------------------------------+
|                                                0 |
+--------------------------------------------------+
1 row in set (4.74 sec)

Le temps affiché est le temps côté client, et non pas les ressources processeurs consommées. il est conseillé d'utiliser BENCHMARK() plusieurs fois de suite pour interpréter un résultat, en dehors de charges ponctuelles sur le serveur.

CHARSET(str)

Retourne le jeu de caractères de la chaîne argument.

mysql> SELECT CHARSET('abc');
        -> 'latin1'
mysql> SELECT CHARSET(CONVERT('abc' USING utf8));
        -> 'utf8'
mysql> SELECT CHARSET(USER());
        -> 'utf8'

CHARSET() a été ajouté en MySQL version 4.1.0.

COERCIBILITY(str)

Retourne la coercibilité de la collation de la chaîne argument.

mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);
        -> 0
mysql> SELECT COERCIBILITY('abc');
        -> 3
mysql> SELECT COERCIBILITY(USER());
        -> 2

Les valeurs retournées possibles sont :

Les valeurs les plus faibles ont la plus haute priorité.

COERCIBILITY() a été ajouté en MySQL version 4.1.1.

COLLATION(str)

Retourne la collation du jeu de caractères de la chaîne argument.

mysql> SELECT COLLATION('abc');
        -> 'latin1_swedish_ci'
mysql> SELECT COLLATION(_utf8'abc');
        -> 'utf8_general_ci'

COLLATION() a été ajouté en MySQL version 4.1.0.

CONNECTION_ID()

Retourne l'identifiant de connexion courant (thread_id). Chaque connexion a son propre identifiant unique.

mysql> SELECT CONNECTION_ID();
        -> 23786

CONNECTION_ID() a été ajouté en MySQL version 3.23.14.

CURRENT_USER()

Retourne le nom d'utilisateur et le nom d'hôte de la session courante. Cette valeur correspond au compte qui a été utilisé durant l'identification auprès du serveur. Cela peut être différent des valeurs de USER().

mysql> SELECT USER();
        -> 'davida@localhost'
mysql> SELECT * FROM mysql.user;
ERROR 1044: Access denied for user: '@localhost' to
database 'mysql'
mysql> SELECT CURRENT_USER();
        -> '@localhost'

Cet exemple montre que même si le client a indiqué le nom d'utilisateur davida (comme mentionné par la fonction USER()), le serveur a identifié le client comme un utilisateur anonyme (comme indiqué par la fonction CURRENT_USER()). Une situation qui arrive s'il n'y a aucun compte de listé dans les tables de droits pour davida.

CURRENT_USER() a été ajouté en MySQL version 4.0.6.

DATABASE()

Retourne le nom de la base de données courante :

mysql> SELECT DATABASE();
        -> 'test'

Si aucune base de données n'a été sélectionnée, DATABASE() retourne une chaîne vide. A partir de la version 4.1.1, elle retourne NULL.

FOUND_ROWS()

Une commande SELECT peut inclure une clause LIMIT pour restreindre le nombre de lignes qui sera retournée par le client. Dans certains cas, il est mieux de savoir combien de lignes une commande aurait retourné, sans la clause LIMIT, mais sans lancer à nouveau le calcul. Pour cela, ajoutez l'option SQL_CALC_FOUND_ROWS dans la commande SELECT, puis appelez FOUND_ROWS() après :

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
    -> WHERE id > 100 LIMIT 10;
mysql> SELECT FOUND_ROWS();

Le second SELECT retourne un nombre indiquant combien de lignes le premier SELECT aurait retourné s'il n'avait pas été écrit avec une clauseLIMIT.

Notez que si vous utilisez SELECT SQL_CALC_FOUND_ROWS ..., MySQL calcule toutes les lignes dans la liste des résultats. Ainsi, c'est plus rapide si vous n'utilisez pas de clause LIMIT et que la liste des résultats n'a pas besoin d'être envoyée au client. Si la commande SELECT précédente n'inclut pas l'option SQL_CALC_FOUND_ROWS, alors FOUND_ROWS() pourrait retourner une valeur différente suivant que LIMIT est utilisé ou pas.

SQL_CALC_FOUND_ROWS et FOUND_ROWS() peuvent être pratiques dans des situations où vous devez limiter le nombre de lignes que la requête retourne, mais que vous devez tout de même connaître le nombre de ligne total, sans exécuter une seconde requête. Un exemple classique est un script web qui présente des résultats de recherche. En utilisant FOUND_ROWS(), vous connaîtrez facilement le nombre de lignes de résultat.

L'utilisation de SQL_CALC_FOUND_ROWS et FOUND_ROWS() est plus complexe pour les requêtes UNION que pour les commandes SELECT simples, car LIMIT peut intervenir plusieurs fois dans une commande UNION. Elle sera appliquée à différentes commandes SELECT de la commande UNION, ou globalement à l'UNION.

Le but de SQL_CALC_FOUND_ROWS pour UNION est de retourner le nombre de lignes qui aurait été retourné sans la clause globale LIMIT. Les conditions d'utilisation de SQL_CALC_FOUND_ROWS avec UNION sont :

SQL_CALC_FOUND_ROWS et FOUND_ROWS() sont disponibles à partir de la version 4.0.0 de MySQL.

LAST_INSERT_ID(), LAST_INSERT_ID(expr)

Retourne le dernier identifiant automatiquement généré par une colonne AUTO_INCREMENT.

mysql> SELECT LAST_INSERT_ID();
        -> 195

Le dernier ID généré est conservé par le serveur pour chaque connexion. Un autre client ne la modifiera donc pas, même s'ils génèrent une autre valeur AUTO_INCREMENT de leur coté. Ce comportement permet de s'assurer que les actions des autres clients ne perturbe pas les actions du client en cours.

La valeur de LAST_INSERT_ID() ne sera pas modifiée non plus si vous modifiez directement la valeur d'une colonne AUTO_INCREMENT avec une valeur simple (c'est à dire, une valeur qui n'est ni NULL, ni 0).

Si vous insérez plusieurs lignes au même moment avec une requête INSERT, LAST_INSERT_ID() retourne la valeur de la première ligne insérée. La raison à cela est que cela rend possible la reproduction facilement la même requête INSERT sur d'autres serveurs.

Si vous utilisez une commande INSERT IGNORE et que la ligne est ignorée, le compteur AUTO_INCREMENT sera malgré tout incrémenté, et LAST_INSERT_ID() retournera une nouvelle valeur.

Si expr est donnée en argument à la fonction LAST_INSERT_ID(), alors la valeur de l'argument sera retourné par la fonction et sera enregistré comme étant la prochaine valeur retournée par LAST_INSERT_ID(). Cela peut être utilisé pour simuler des séquences :

Vous pouvez générer des séquences sans appeler la fonction LAST_INSERT_ID(), mais l'utilité d'utiliser cette fonction cette fois si est que la valeur ID est gérée par le serveur comme étant la dernière valeur générée automatiquement. (sécurité multi-utilisateur). Vous pouvez retrouver la nouvelle ID tout comme vous pouvez lire n'importe quelle valeur AUTO_INCREMENT dans MySQL. Par exemple, la fonction LAST_INSERT_ID() (sans argument) devrait retourner la nouvelle ID. La fonction C de l'API mysql_insert_id() peut être également utilisée pour trouver cette valeur.

Notez que la fonction mysql_insert_id() est incrémentée uniquement après des requêtes INSERT et UPDATE, donc, vous ne pouvez pas utiliser la fonction C de l'API pour trouver la valeur de LAST_INSERT_ID(expr) après avoir exécuté d'autres types de requêtes, comme SELECT ou bien SET.

SESSION_USER()

SESSION_USER() est un synonyme de USER().

SYSTEM_USER()

SYSTEM_USER() est un synonyme de USER().

USER()

Retourne le nom d'utilisateur et le nom d'hôte courant MySQL :

mysql> SELECT USER();
        -> 'davida@localhost'

La valeur indique le nom d'utilisateur qui a été spécifié lors de l'identification avec le serveur MySQL, et l'hôte client avec lequel il est connecté.

Avant la version 3.22.11, la fonction ne retournait pas le nom d'hôte. Vous pouvez extraire le nom d'utilisateur sans l'hôte avec la commande suivante :

mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);
        -> 'davida'

Depuis MySQL version 4.1, USER() retourne la valeur au format utf8. Assurez vous que la chaîne '@' est bien interprétée dans ce jeu de caractères :

mysql> SELECT SUBSTRING_INDEX(USER(),_utf8'@',1);
        -> 'davida'

VERSION()

Retourne une chaîne indiquant la version courante du serveur MySQL :

mysql> SELECT VERSION();
        -> '4.1.2-alpha-log'

Notez que si votre version se termine par -log, cela signifie que le système d'historique est actif.

FORMAT(X,D)

Formate l'argument X en un format comme '#,###,###.##', arrondi à D décimales. Si D vaut 0, le résultat n'aura ni séparateur décimal, ni partie décimale :

mysql> SELECT FORMAT(12332.123456, 4);
        -> '12,332.1235'
mysql> SELECT FORMAT(12332.1,4);
        -> '12,332.1000'
mysql> SELECT FORMAT(12332.2,0);
        -> '12,332'

GET_LOCK(str,timeout)

Tente de poser un verrou nommé str, avec un délai d'expiration (timeout) exprimé en seconde. Retourne 1 si le verrou a été posé avec succès, 0 si il n'a pas pu être posé avant l'expiration du délai et NULL si une erreur est survenu (comme par exemple un manque de mémoire, ou la mort du thread lui-même, par mysqladmin kill). Un verrou sera levé lorsque vous exécuterez la commande RELEASE_LOCK(), GET_LOCK() ou si le thread se termine. Cette fonction peut être utilisée pour implémenter des verrous applicatifs ou pour simuler des verrous de lignes. Les requêtes concurrentes des autres clients de même nom seront bloquées ; les clients qui s'entendent sur un nom de verrou peuvent les utiliser pour effectuer des verrouillages coopératifs :

mysql> SELECT GET_LOCK("lock1",10);
        -> 1
mysql> SELECT IS_FREE_LOCK("lock2");
        -> 1
mysql> SELECT GET_LOCK("lock2",10);
        -> 1
mysql> SELECT RELEASE_LOCK("lock2");
        -> 1
mysql> SELECT RELEASE_LOCK("lock1");
        -> NULL

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

INET_ATON(expr)

Retourne un entier qui représente l'expression numérique de l'adresse réseau. Les adresses peuvent être des entiers de 4 ou 8 octets.

mysql> SELECT INET_ATON("209.207.224.40");
       ->  3520061480

Le nombre généré est toujours dans l'ordre des octets réseau ; par exemple, le nombre précédent est calculé comme ceci : 209*256^3 + 207*256^2 + 224*256 +40.

Depuis MySQL 4.1.2, INET_ATON() comprend aussi les IP courtes :

mysql> SELECT INET_ATON('127.0.0.1'), INET_ATON('127.1');
        -> 2130706433, 2130706433

INET_ATON() a été ajouté en MySQL 3.23.15.

INET_NTOA(expr)

Retourne l'adresse réseau (4 ou 8 octets), de l'expression numérique exp :

mysql> SELECT INET_NTOA(3520061480);
       ->  "209.207.224.40"

IS_FREE_LOCK(str)

Regarde si le verrou nommé str peut être librement utilisé (i.e., non verrouillé). Retourne 1 si le verrou est libre (personne ne l'utilise), 0 si le verrou est actuellement utilisé et NULL si une erreur survient (comme un argument incorrect).

IS_USED_LOCK(str)

Vérifie si le verrou appelé str est actuellement posé ou pas. Si c'est le cas, la fonction retourne l'identifiant de connexion qui a le verrou. Sinon, elle retourne NULL.

IS_USED_LOCK() a été ajouté en MySQL version 4.1.0.

MASTER_POS_WAIT(log_name, log_pos)

Bloque le maître jusqu'à ce que l'esclave atteigne une position donnée dans le fichier d'historique principal, durant une réplication. Si l'historique principal n'est pas initialisé, retourne NULL. Si l'esclave n'est pas démarré, le maître restera bloqué jusqu'à ce que l'esclave soit démarré et ai atteint la position demandée. Si l'esclave a déjà dépassé cette position, la fonction se termine immédiatement. La valeur retournée est le nombre d'évènements qui a du être traité pour atteindre la position demandée, ou NULL en cas d'erreur. Cette fonction est très utile pour contrôler la synchronisation maître-esclave, mais elle a été initialement écrite pour faciliter les tests de réplications.

RELEASE_LOCK(str)

Libère le verrou nommé str, obtenu par la fonction GET_LOCK(). Retourne 1 si le verrou a bien été libéré, 0 si le verrou n'a pas été libéré par le thread (dans ce cas, le verrou reste posé) et NULL si le nom du verrou n'existe pas. Le verrou n'existe pas si il n'a pas été obtenu par la fonction GET_LOCK() ou si il a déjà été libéré.

La commande DO est utilisable avec RELEASE_LOCK(). See Section 13.1.2, « Syntaxe de DO ».

UUID()

Retourne un Universal Unique Identifier (UUID) généré grâce à ``DCE 1.1: Remote Procedure Call'' (Appendix A) CAE (Common Applications Environment) Specifications, publié par le The Open Group en octobre 1997 (Document numéro C706).

Un UUID est con¸u comme un numéro qui est globalement unique dans l'espace, et le temps. Deux appels à UUID() sont supposés générer deux valeurs différentes, même si ces appels sont faits sur deux ordinateurs séparés, qui ne sont pas connectés ensembles.

Un UUID est un nombre de 128 bits, représenté par une chaîne de 5 nombres hexadécimaux, au format aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee :

mysql> SELECT UUID();
        -> '6ccd780c-baba-1026-9564-0040f4311e29'

Notez que UUID() ne fonctionne pas encore avec la réplication.

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

AVG(expr)

Retourne la moyenne de l'expression expr :

mysql> SELECT student_name, AVG(test_score)
    ->        FROM student
    ->        GROUP BY student_name;

BIT_AND(expr)

Retourne la combinaison AND bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT).

Depuis MySQL 4.0.17, cette fonction retourne 18446744073709551615 s'il n'y avait pas de lignes. (C'est un entier BIGINT non-signé, dont tous les bits sont à 1.) Avant 4.0.17, la fonction retournait -1 s'il n'y avait pas de ligne trouvées.

BIT_OR(expr)

Retourne la combinaison OR bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT).

Cette fonction retourne 0 s'il n'y a pas de ligne à traiter.

BIT_XOR(expr)

Retourne la combinaison XOR bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT).

Cette fonction retourne 0 s'il n'y a pas de ligne à traiter.

Cette fonction est disponible depuis MySQL 4.1.1.

COUNT(expr)

Retourne le nombre de valeurs non-NULL dans les lignes lues par la commande SELECT :

mysql> SELECT student.student_name,COUNT(*)
    ->        FROM student,course
    ->        WHERE student.student_id=course.student_id
    ->        GROUP BY student_name;

COUNT(*) est un peu différente dans son action, car elle retourne le nombre de lignes, même si elles contiennent NULL.

COUNT(*) est optimisée pour retourner très rapidement un résultat si SELECT travaille sur une table, qu'aucune autre colonne n'est lue, et qu'il n'y a pas de clause WHERE. Par exemple :

mysql> SELECT COUNT(*) FROM student;

Cette optimisation s'applique uniquement pour les tables MyISAM et ISAM, car un compte exact du nombre de lignes est stocké pour ces types de tables, et il peut être lu très rapidement. Pour les moteurs de tables transactionnels, (InnodB, BDB), le stockage de cette valeur est plus problématique, car plusieurs transactions peuvent survenir en même temps, et affecter toutes ce compte.

COUNT(DISTINCT expr,[expr...])

Retourne le nombre de valeurs non-NULL distinctes :

mysql> SELECT COUNT(DISTINCT results) FROM student;

Avec MySQL, vous pouvez lire le nombre d'expression distinctes qui ne contiennent pas NULL, en pla¸ant ici une liste d'expression. Avec SQL-99, vous devriez faire une concaténation de toutes les expressions dans COUNT(DISTINCT ...).

GROUP_CONCAT(expr)

Syntaxe complète :

GROUP_CONCAT([DISTINCT] expr [,expr ...]
             [ORDER BY {unsigned_integer | col_name | formula} [ASC | DESC] [,col ...]]
             [SEPARATOR str_val])

Cette fonction a été ajoutée en MySQL version 4.1. Elle retourne la chaîne résultant de la concaténation de toutes les valeurs du groupe :

mysql> SELECT student_name,
    ->        GROUP_CONCAT(test_score)
    ->        FROM student 
    ->        GROUP BY student_name;

ou :

mysql> SELECT student_name,
    ->        GROUP_CONCAT(DISTINCT test_score
    ->                     ORDER BY test_score DESC SEPARATOR " ")
    ->        FROM student
    ->        GROUP BY student_name;

Avec MySQL, vous pouvez obtenir la concaténation d'une série d'expressions. Vous pouvez éliminer les doublons en utilisant DISTINCT. Si vous voulez trier les valeurs du résultat, il faut utiliser ORDER BY. Pour trier en ordre inverse, ajoutez le mot clé DESC (descendant) au nom de la colonne que vous triez dans la clause ORDER BY. Par défaut, l'ordre est ascendant. Cela peut être spécifié explicitement avec le mot clé ASC. SEPARATOR est une chaîne qui sera insérée entre chaque valeur du résultat. La valeur par défaut est une virgule ‘","’. vous pouvez supprimer le séparateur en spécifiant la chaîne vide SEPARATOR "".

Vous pouvez donner une taille maximale à la variable group_concat_max_len de votre configuration. La syntaxe pour faire cela durant l'exécution est :

SET [SESSION | GLOBAL] group_concat_max_len = unsigned_integer;

Si une taille maximale a été atteinte, le résultat sera tronqué à cette taille maximale.

Note : il y a encore de petites limitations pour GROUP_CONCAT() lorsqu'il faut utiliser des valeurs DISTINCT avec ORDER BY et et en utilisant les valeurs BLOB. Voyez Section 1.5.7.4, « Bugs connus / limitations de MySQL ».

GROUP_CONCAT() a été ajoutée en MySQL 4.1.

MIN(expr), MAX(expr)

Retourne le minimum ou le maximum de expr. MIN() et MAX() peuvent prendre des chaînes comme argument : dans ce cas, elles retournent la valeur minimale ou maximale de la valeur de la chaîne. See Section 7.4.5, « Comment MySQL utilise les index ».

mysql> SELECT student_name, MIN(test_score), MAX(test_score)
    ->        FROM student
    ->        GROUP BY student_name;

Actuellement, MIN(), MAX() et d'autres fonctions d'agrégation MySQL, le serveur compare les valeurs de type ENUM et SET avec leur valeur de chaîne, et non pas leur position relative dans l'ensemble. Ce sera corrigé.à

STD(expr), STDDEV(expr)

Retourne la déviation standard de expr (la racine carrée de la VARIANCE(). Ceci est une extension au standard SQL 99. La forme STDDEV() de cette fonction est fournie pour assurer la compatibilité Oracle.

SUM(expr)

Retourne la somme de expr. Notez que si le résultat ne contient pas de ligne, cette fonction retournera NULL.

VARIANCE(expr)

Retourne la variance standard de l'expression expr (en considérant que les lignes forment une population totale, et non pas un échantillon. Le nombre de ligne est le dénominateur. C'est une extension à la norme SQL-99 (disponible en version version 4.1 ou plus récent).

Après chaque jeu de ligne sur les produits, pour une année et un pays donnée, un résumé est ajouté, indiquant le total de tous les produits. Ces lignes voient leur colonne product contenir la valeur NULL.

Après chaque jeu de ligne couvrant une année particulière, une nouvelle ligne est ajoutée pour afficher le total de tous les pays et produits, pour cette année la. Ces lignes voient leurs colonnes country et products contenir NULL.

Finalement, suivant toutes les autres lignes, un résumé général est produit, avec le grand total de toutes les années, pays et produits. Cette ligne contient la valeur NULL pour toutes les colonnes year, country et products.