1.1. Requête « Sélection » Requête « Sélection »

MySQL : requête SQL sur une table

1. 1. Requête « Sélection » Requête « Sélection »

Objectif :

* Utiliser l'opérateur « SELECT » qui permet de rechercher (sélectionner) des informations dans une base de données avec des conditions avec une expression logique

* Filtrer et trier le résultat de l'opérateur « SELECT »

➢ synthèse sur des éléments abordés :

SELECT [nom_table.nom_champs, nom_table.nom_champs2...] [champs calculés]

FROM

nom_table1, nom_table2 ….

WHERE

ORDER BY [nom_table.nom_champs] [DESC]

[LIMIT]

● Par exemple :

SELECT * FROM catalogue WHERE ref="123abc"; (* : tous les champs) SELECT Client.NomClient FROM Client WHERE Client.PrivilegeClient=true ORDER by Client.NomClient;

[conditions]SQL comparateur Les opérateurs

Les expressions logiques AND OR

NOT

Un champ compris entre 2 valeurs nom_champ BETWEEN 1 and 30

Une chaine de caractères comme ...( comparaison ) nom_champ like "123"&"%"

Un champ est vide nom_champ is NULL Utilisation de date

"aaaa-mm-jj"

Pour trier les champs

ORDER BY ETU_Nom [ASC] « CROISSANT » ORDER BY ETU_Nom DESC « DECROISSANT » Sélectionner des résultats non redondants (distincts)

SELECT DISTINCT nom_champ … Quand un champ a pour valeurs (...)

WHERE nom_champ IN ('valeur1', 'valeur2', ...) lors de l'écriture des chaînes de texte

' (apostrophe ou single quote) sert à entourer une valeur de format alphanumérique.

` (accent grave ou backtick, touches Alt Gr + 7) sert à entourer les noms des objets de la BDD (base, table, colonne), surtout lorsque ces noms peuvent être mal interprétés par MySQL : Noms en plusieurs mots ; Mots réservés de MySQL.

" (guillemet ou double quote) est une alternative (propre à MySQL) à ' ; elle est déconseillée, car seul ' est normalisé.

2. 2. Exercice : partie 1 => création de la table Exercice : partie 1 => création de la table

Créer une table pour gérer des étudiants , avec comme nom de la table : Etudiant et comme champs dans la table :

idEtudiant : ce champ est de type entier, c'est une clé primaire qui utilise un attribut «AUTO_INCREMENT».

nom : ce champ est de type chaîne de caractères variable de taille 20 caractères maximum.

adresse : ce champ est de type chaîne de caractères variable de taille 40 caractères maximum.

ville : ce champ est de type chaîne de caractères variable de taille 20 caractères maximum.

code_postal : ce champ est de type entier, qui affiche un numérique sur 5 chiffres

telephone : ce champ est de type NUMERIC ( une chaîne de caractères) qui affiche un numérique sur 10 digits (quelque soit la valeur )

date_naissance: ce champ est de Date

sexe : ce champ est de type chaîne de caractères variable de taille 1 caractère maximum.

boursier : ce champ est de type chaîne de caractères variable de taille 1 caractère maximum.

groupe_id : ce champ est de type entier semestre_id : ce champ est de type entier

note_ue1 : ce champ est de type Réel qui affiche un numérique avec 2 chiffres après la virgule, la valeur la plus grande est 99,99

note_ue2 : ce champ est de type Réel qui affiche un numérique avec 2 chiffres après la virgule, la valeur la plus grande est 99,99

Après avoir créer la table ci dessus :

Utiliser le fichier joint pour insérer des enregistrements

Etudiant idEtudiant nom

adresse ville

code_postal telephone date_naissance sexe

boursier groupe_id semestre_id note_ue1 note_ue2

•

• Requête 1 (expression logique) :Requête 1 (expression logique) : Tester la requête suivante :

Sur le même principe :

Écrire une requête pour sélectionner le nom, le groupe et le champ ‘boursier’ (si ils sont boursiers ou non) des étudiants du groupe 1, du semestre 1 quand ils sont boursiers.

Résultat :

+---+---+---+

| nom | groupe_id | boursier | +---+---+---+

| PEQUIGNOT | 1 | O |

| MONNIER | 1 | O | +---+---+---+

•

• Requête 2 (expression logique et tri sur plusieurs champs ) :Requête 2 (expression logique et tri sur plusieurs champs ) :

Requête 2-1

Requête 2-1  : : Tester la requête suivanteTester la requête suivante  : Afficher tous les étudiants triés par semestre, : Afficher tous les étudiants triés par semestre, puis par groupe, puis par nom dans l’ordre décroissant.

puis par groupe, puis par nom dans l’ordre décroissant.

Utiliser l'instruction ORDER BY champ1, champ2, champ3 ; remplacer « champ » par le nom du champ suivi de ASC ou DESC (par défaut le tri est fait de façon ascendante)

Aidez vous des informations sur : https://www.w3schools.com/SQL/sql_orderby.asp

Utiliser l'instruction ORDER BY « champ1 » après l'instruction WHERE « conditions ».

Aidez vous des informations sur : https://www.w3schools.com/SQL/sql_orderby.asp Requête 2-2 : Tester la requête suivante :

Sur le même principe :

Requête 2-3 : Écrire une requête pour sélectionner uniquement les étudiants (nom, groupe, ville, semestre ) du groupe 1 et du semestre 1 ou du semestre 2 et de la ville de

« Belfort ». Ordonner la liste résultat par semestre croissant puis par groupe croissant puis par nom de ville croissante (par ordre alphabétique) puis par nom d’étudiant décroissant.

Résultat :

+---+---+---+---+

| nom | groupe_id | ville | semestre_id | +---+---+---+---+

| ZILLIOX | 1 | Bavilliers | 1 |

| BERNARD | 1 | Belfort | 1 |

| MONNIER | 1 | TAILLECOURT | 1 |

| PEQUIGNOT | 1 | Valdoie | 1 |

| MOREAU | 1 | Belfort | 2 |

| LUZET | 1 | Belfort | 2 |

| BOULANGER | 1 | Belfort | 2 |

| BONVALOT | 1 | Belfort | 2 |

| PRETTOT | 2 | Belfort | 2 | +---+---+---+---+

Requête 2-4

Requête 2-4  : : Dans la requête ci-dessous, simplifier l’expression dans le WHERE:Dans la requête ci-dessous, simplifier l’expression dans le WHERE:

Requête 2-5 : Écrire une requête pour sélectionner uniquement les étudiants (nom, groupe, ville, semestre, boursier ) qui sont boursiers ou qui habitent la ville de belfort et qui sont tous du semestre 2 (trier les enregistrements par groupe puis ville puis nom de façon ascendante).

Résultat :

+---+---+---+---+---+

| nom | groupe_id | ville | semestre_id | boursier | +---+---+---+---+---+

| BONVALOT | 1 | Belfort | 2 | O |

| BOULANGER | 1 | Belfort | 2 | N |

| LUZET | 1 | Belfort | 2 | O |

| MOREAU | 1 | Belfort | 2 | O |

| VALOT | 2 | | 2 | O |

| PRETTOT | 2 | Belfort | 2 | O |

| VALZER | 3 | Valdoie | 2 | O | +---+---+---+---+---+

•• Requête 3 Requête 3 (utilisation de DISTINCT)(utilisation de DISTINCT)

Requête 3-1 : Tester la requête suivante avec et sans le mot clé distinct :

Requête 3-2 : Écrire la requête pour afficher les villes distinctes de tous les étudiants dont le code postal commence par 90 et dont le nom de ville n'est pas NULL et n'est pas une chaîne vide. Utiliser le mot clé DISTINCT.

Résultat :

+---+

| ville | +---+

| Belfort |

| Valdoie |

| Bavilliers | +---+

Aidez vous des informations sur : https://www.w3schools.com/sql/sql_distinct.asp

•

• Requête 4 ( IN : un champ appartient à une liste de valeurs )Requête 4 ( IN : un champ appartient à une liste de valeurs )

Écrire une requête pour sélectionner les étudiants et les villes dont la ville appartient à cette liste ('strasbourg','mulhouse','cernay'). Utiliser l'instruction IN

Aidez vous des informations sur : https://www.w3schools.com/SQL/sql_in.asp Résultat :

+---+---+

| nom | ville | +---+---+

| FONTAINE-LEGIOT | Mulhouse |

| FAIVRE | Cernay |

| CHAVEAUX | Strasbourg | +---+---+

•• Requête 5 (utilisation de NULL)Requête 5 (utilisation de NULL)

Écrire la requête pour sélectionner le nom des étudiants dont le champ de la ville est vide (Utiliser l'instruction IS NULL) et dont le sexe est « H ».

Résultat :

+---+---+

| nom | ville | +---+---+

| VERNET | NULL |

| BAILLIT | NULL | +---+---+

Remarque : NULL est un cas particulier, on n’écrit jamais =NULL ou <>NULL mais IS NULL ou IS NOT NULL, voir https://www.w3schools.com/SQL/sql_null_values.asp

Faire la même requête mais en rajoutant les étudiants dont le champ de la ville est une chaîne de caractères vide

+---+---+

| nom | ville | +---+---+

| VALOT | |

| VERNET | NULL |

| BAILLIT | NULL |

| DUPONT | | +---+---+

•• Requête 6 (utilisation de LIKE )Requête 6 (utilisation de LIKE )

Requête pour afficher le Nom des étudiants et leur ville. Le nom des étudiants commence par « B » ou « D » et ils habitent une ville qui possède la lette « o » (triés par nom).

Ecrire une requête pour afficher le nom la ville et l’adresse des étudiants dont l’adresse est composée du mot « verger » et dont la ville est composée des lettres « er » ou des lettres « a » suivie de « l »

•

• Requête 7 (utilisation de LIMIT )Requête 7 (utilisation de LIMIT )

La requête ci-dessous retourne les 10 enregistrements de la position 6 à 15 SELECT nom

FROM Etudiant ORDER BY nom LIMIT 5,10 ;

(https://dev.mysql.com/doc/refman/5.7/en/select.html) Tester et utiliser la lien ci-dessous pour

https://www.w3schools.com/SQL/sql_top.asp

Dans une page Web, on désire sélectionner les 6 premiers étudiants triés par Groupe (descendant : plus grand au plus petit) puis par Nom (pour ordre

alphabétique). Écrire la requête, utiliser l'instruction LIMIT pour limiter le nombre d’enregistrements selectionnés.

Résultat :

+---+---+

| nom | groupe_id | +---+---+

| BAILLIT | 4 |

| DUPONT | 4 |

| VERNET | 4 |

| DUCHENNE | 3 |

| FAIVRE | 3 |

| FAIVRE | 3 | +---+---+

sélectionner les 4 suivants

+---+---+

| nom | groupe_id | +---+---+

| FONTAINE-LEGIOT | 3 |

| KENDE | 3 |

| KLEIN | 3 |

| PY | 3 | +---+---+

remarque : cette instruction n'est pas très normalisée d'un SGBD à l'autre // mysql

SELECT col FROM matable LIMIT 20;

// Oracle

SELECT col FROM matable WHERE rownum<=20;

// Microsoft SQL (top ou first)

SELECT TOP 20 col FROM matable;

•

• Requête 8Requête 8 (requête avec des dates, fonctions now(), day(), month(), year()) (requête avec des dates, fonctions now(), day(), month(), year()) Écrire une requête pour afficher le nom et le groupe des étudiants dont la date de naissance est comprise entre le "2000-1-1" And "2000-12-31", qui sont des hommes et qui habitent Belfort ou Montbéliard (utiliser le code postal 90000 (Belfort) et

25200(Montbéliard)). Proposer une deuxième solution avec comme condition (dans le « WHERE ») : l’année est égale à "2000". (trier l’affichage par date de naissance)

+---+---+

| nom | date_naissance | +---+---+

| LUZET | 2000-01-01 |

| VALOT | 2000-12-12 | +---+---+

* selon les mises à jour, votre résultat peut être différent

Aidez vous des informations sur https://www.w3schools.com/sql/sql_ref_mysql.asp.

Rechercher la fonction « YEAR ».

Pour les plus rapides

•

• Requête 9 (expressions régulières)Requête 9 (expressions régulières)

Aidez vous des informations la documentation en annexe (suivre le lien) pour les

expressions régulières ou sur : https://dev.mysql.com/doc/refman/5.7/en/regexp.html et https://www.w3schools.com/SQL/sql_like.asp

Avec la documentation ci dessus (cas de LIKE puis de REGEXP):

* Rechercher une expression régulière qui commence par un chiffre, suivi du chiffre "5", et de 3 chiffres (format D5DDD, D appartient à [0-9]).

* Rechercher une expression régulière qui commence par un caractère, suivi du caractère

"a" ou "e" puis de n'importe quel caractère.

• Écrire une requête pour sélectionner le nom des étudiants dont le nom a comme 2eme caractère "a" ou "e" et dont le code postal a comme 2eme chiffre "5" en utilisant LIKE (champ LIKE « expression en remplaçant _ pour un caractère et % pour une chaîne de caractères»)

• Écrire une requête pour sélectionner le nom des étudiants dont le nom a comme 2eme caractère "a" ou "e" et dont le code postal a comme 2eme chiffre "5" en utilisant REGEXP (champ REGEXP « expression régulière »), (LIKER idem).

Remarque : LIKE est plus rapide que REGEXP, voir article

https://www.psce.com/en/blog/2012/03/31/mysql-queries-with-regexp/

Résultat :

+---+---+

| nom | code_postal | +---+---+

| BAILLIT | 25200 | +---+---+

•• Requête 10Requête 10

Écrire une requête pour sélectionner les étudiants qui ont plus de 20 ans après le 30 septembre de la fin de l'année universitaire (mois de naissance inférieur à 10 si c'est l'année de leur 20 ans). Ces étudiants doivent payer une sécurité sociale si ils ne sont pas boursiers . Ordonner les étudiants du plus jeune au plus vieux.

Pour plus d'informations : http://www.etudiant.gouv.fr/pid20411/sante.html

commencer par tester : SELECT day(now());

SELECT month(now());

SELECT year(now());

idée : plus de 20 ans entre aujourd'hui et leur date de naissance ou 20 ans et

…..

Résultat :

+---+---+

| nom | date_naissance | +---+---+

| FONTAINE-LEGIOT | 2000-01-01 |

| FAIVRE | 2000-01-01 |

| BOULANGER | 2000-01-01 |

| MOREAU | 1999-06-01 | +---+---+

* selon les mises à jour, votre résultat peut être différent

Si les dates ne sont pas correctes, utiliser l'instruction SQL suivante pour les mettre à jour UPDATE Etudiant SET date_naissance=DATE_ADD(date_naissance,INTERVAL 1 YEAR);

ANNEXE

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

Remarque : les opérateurs

:=

||, OR, XOR

&&, AND

BETWEEN, CASE, WHEN, THEN, ELSE

=, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN

|

&

<<, >>

-, +

*, /, DIV, %, MOD

^

- (unary minus), ~ (unary bit inversion) NOT, !

BINARY, COLLATE

<=>

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

<>, !=

Différent :

mysql> SELECT '.01' <> '0.01';

-> 1

mysql> SELECT .01 <> '0.01';

-> 0

mysql> SELECT 'zapp' <> 'zappp';

-> 1

0 is not NULL !

ANNEXE

https://regex101.com/r/Xvt5U6/2

^[0-9]{1,2}\/(0[1-9]{1}|[1-9]{1})\/[0-9]{4}$

8/07/2020 9/12/2020 02/09/2020 22/12/2020 12/02/2020 02/02/2020 12/12/2020 02/02/202 02/02/20222

Expressions régulières MySQL

Une expression régulière (regex) est la meilleure méthode pour spécifier une recherche complexe.

MySQL utilise l'implémentation de Henry Spencer des expressions régulières qui tend à être conforme à POSIX 1003.2. MySQL en utilise la version étendue.

Ceci est une référence simplifiée qui n'aborde pas les détails. Pour avoir plus

d'informations détaillées, regardez la page de manuel regex(7) de Henry Spencer qui est inclue dans la distribution des sources. Contributeurs .

Une expression régulière décrit un jeu de chaînes de caractères. La plus simple est celle qui ne comporte pas de caractères spéciaux. Par exemple, la regexp bonjour trouvera bonjour et rien d'autre.

Les expression régulières non-trivialles utilisent des constructions spéciales pour pouvoir trouver plus d'une chaîne. Par exemple, la regexp bonjour|monde trouve la chaîne bonjour ou la chaîne monde .

Voici un exemple encore plus complexe : la regexp B[an]*s trouve l'une des chaînes suivantes Bananas , Baaaaas , Bs , et n'importe quelle autre chaîne commençant par un B , se terminant par un s , et contenant n'importe quel nombre de a et de n au milieu. Une expression régulière peut utiliser l'un des caractères spéciaux ou constructions suivants : ^

Correspond au début de la chaîne.

mysql> SELECT "fo\nfo" REGEXP "^fo$"; -> 0 mysql> SELECT "fofo" REGEXP "^fo"; -> 1 $

Correspond à la fin de la chaîne.

mysql> SELECT "fo\no" REGEXP "^fo\no$"; -> 1 mysql> SELECT "fo\no" REGEXP "^fo$"; -> 0 .

N'importe quel caractère (nouvelle ligne inclus).

mysql> SELECT "fofo" REGEXP "^f.*"; -> 1

Remarque : dans la documentation ci contre, les exemples sont très simplifiés, donc voici un exemple : SELECT nom

FROM Etudiant WHERE

nom REGEXP '^f.*';

Retourne les étudiant dont le nom commence par « f »

^(début de chaine), le caractère

« f » puis n'importe quel caractère

répété zéro ou n fois

mysql> SELECT "fo\nfo" REGEXP "^f.*"; -> 1 a*

Correspond à toute séquence de zéro ou plus caractères a .

mysql> SELECT "Ban" REGEXP "^Ba*n"; -> 1 mysql> SELECT "Baaan" REGEXP "^Ba*n"; -> 1 mysql> SELECT "Bn" REGEXP "^Ba*n"; -> 1 a+

Correspond à toute séquence de un ou plus caractères a .

mysql> SELECT "Ban" REGEXP "^Ba+n"; -> 1 mysql> SELECT "Bn" REGEXP "^Ba+n"; -> 0 a?

Correspond à zéro ou un caractère a .

mysql> SELECT "Bn" REGEXP "^Ba?n"; -> 1 mysql> SELECT "Ban" REGEXP "^Ba?n"; -> 1 mysql> SELECT "Baan" REGEXP "^Ba?n"; -> 0 de|abc

Correspond aux séquences de de ou de abc .

mysql> SELECT "pi" REGEXP "pi|apa"; -> 1 mysql> SELECT "axe" REGEXP "pi|apa"; -> 0 mysql> SELECT "apa" REGEXP "pi|apa"; -> 1 mysql> SELECT "apa" REGEXP "^(pi|apa)$"; -> 1 mysql> SELECT "pi" REGEXP "^(pi|apa)$"; -> 1 mysql> SELECT "pix" REGEXP "^(pi|apa)$"; -> 0 (abc)*

Correspond à zéro ou plus séquences de abc .

mysql> SELECT "pi" REGEXP "^(pi)*$"; -> 1 mysql> SELECT "pip" REGEXP "^(pi)*$"; -> 0 mysql> SELECT "pipi" REGEXP "^(pi)*$"; -> 1 {1}

{2,3}

Voici une façon plus générale d'écrire les regexps qui correspondent à plusieurs occurences du dernier atome.

a*

Peut être écrit a{0,} . a+

Peut être écrit a{1,} . a?

Peut être écrit a{0,1} .

Pour être plus précis, un atome suivi d'une accolade contenant un entier i et pas de virgule trouve une séquence de exactement i atomes.

Un atome suivi d'une accolade contenant un entier i et une virgule trouve une séquence de i ou plus atomes.

Un atome suivi d'une accolade contenant deux entiers i et j séparés d'une virgule trouve les séquences de i à j (inclusif) atomes.

Les deux arguements doivent être compris entre 0 et RE_DUP_MAX (par défaut 255), inclusif. S'il y'a deux arguements, le second doit être supérieur ou égal au premier.

[a-dX]

[^a-dX]

Trouve n'importe quel caractère qui est (ou n'est pas, si ^ est utilisé) a , b , c , d ou X . Pour inclure le caractère litéral ] , il doit suivre immédiatement le crochet ouvrant [ . Pour inclure le caractère litéral - , il doit être écrit en premier ou en dernier. Ce qui fait que [0-9] correspond à n'importe quel chiffre. Chaque caractère qui n'a pas de

signification spéciale à l'intérieur une paire de [] ne joue pas de rôle spécial et ne correspond qu'à lui même.

mysql> SELECT "aXbc" REGEXP "[a-dXYZ]"; -> 1 mysql> SELECT "aXbc" REGEXP "^[a-dXYZ]$"; -> 0 mysql> SELECT "aXbc" REGEXP "^[a-dXYZ]+$"; -> 1 mysql> SELECT "aXbc" REGEXP "^[^a-dXYZ]+$"; -> 0 mysql> SELECT "gheis" REGEXP "^[^a-dXYZ]+$"; -> 1 mysql> SELECT "gheisa" REGEXP "^[^a-dXYZ]+$"; -> 0 [[.charactères.]]

La séquence de caractères de cet élément d'assemblage. La séquence est un élément de la liste contenue entre les crochets. Une telle expression contenant un élément d'assemblage multi-caractères peut ainsi trouver plus d'un caractère. Par exemple, si la séquence d'assemblage inclut un élément ch , alors l'expression regulière [[.ch.]]*c trouve les cinq premiers caractères de chchcc .

[=character_class=]

Une classe d'équivalence, remplaçant les séquences de caractères de tous les éléments de l'assemblage équivalents à celui-ci, lui même inclut.Par exemple, si o et (+) sont membres d'une classe d'équivalence, alors [[=o=]] , [[=(+)=]] , et [o(+)] sont tous des synonymes. Une classe d'équivalence ne doit pas être un point final d'intervalle.

[:classe_de_caractères:]

Dans une expression entre crochets, le nom d'une classe de caractères entourée de [: et :] remplace la liste de tous les caractères appartenant à cette classe. Les noms des classes de caractères sont :

Nom Nom Nom alnum digit punct alpha graph space blank lower upper cntrl print xdigit

Voilà les classes de caractères définies dans la page de manuel ctype(3) . Une locale peut en fournir d'autres. Une classe de caractère ne doit pas être utilisée en tant que point final d'intervalle.

mysql> SELECT "justalnums" REGEXP "[[:alnum:]]+"; -> 1 mysql> SELECT "!!" REGEXP "[[:alnum:]]+"; -> 0 [[:<:]]

[[:>:]]

Ceux là trouvent la chaîne nulle qui précède et suit chaque mot. Un mot est défini comme étant une séquence de caractères qui n'est ni suivi ni précédée d'un caractère de mot. Un caractère de mot est un caractère alnum (défini par ctype(3) ) ou un tiret bas ( _ ).

mysql> SELECT "a word a" REGEXP "[[:<:]]word[[:>:]]"; -> 1 mysql> SELECT "a xword a" REGEXP "[[:<:]]word[[:>:]]"; -> 0

mysql> SELECT "weeknights" REGEXP "^(wee|week)(knights|nights)$"; -> 1