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. See Annexe B, Crédits. MySQL la
    version améliorée pour supporter les expressions régulières
    effectuées avec REGEXP dans les commandes SQL.
    See Section 3.3.4.7, « Recherche de modèles ».
  
    Ceci est une référence simplifiée qui n'aborde pas les détails.
    Pour avoir plus d'informations, reportez-vous à la page de manuel
    regex(7) de Henry Spencer. Ce manuel est inclus
    dans la distribution MySQL, dans le fichier
    regex.7 du dossier regex.
  
    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, l'expression régulière
    bonjour trouvera bonjour et
    rien d'autre.
  
    Les expression régulières non-triviales utilisent des
    constructions spéciales pour pouvoir trouver plus d'une chaîne.
    Par exemple, l'expression régulière
    bonjour|monde trouve la chaîne
    bonjour ou la chaîne monde.
  
    Voici un exemple encore plus complexe : l'expression régulière
    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$"; -> 0mysql>SELECT "fofo" REGEXP "^fo"; -> 1
        $
      
Correspond à la fin de la chaîne.
mysql>SELECT "fo\no" REGEXP "^fo\no$"; -> 1mysql>SELECT "fo\no" REGEXP "^fo$"; -> 0
        .
      
N'importe quel caractère (nouvelle ligne inclus).
mysql>SELECT "fofo" REGEXP "^f.*"; -> 1mysql>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"; -> 1mysql>SELECT "Baaan" REGEXP "^Ba*n"; -> 1mysql>SELECT "Bn" REGEXP "^Ba*n"; -> 1
        a+
      
        Correspond à toute séquence de un ou plus caractères
        a.
mysql>SELECT "Ban" REGEXP "^Ba+n"; -> 1mysql>SELECT "Bn" REGEXP "^Ba+n"; -> 0
        a?
      
        Correspond à zéro ou un caractère a.
mysql>SELECT "Bn" REGEXP "^Ba?n"; -> 1mysql>SELECT "Ban" REGEXP "^Ba?n"; -> 1mysql>SELECT "Baan" REGEXP "^Ba?n"; -> 0
        de|abc
      
        Correspond aux séquences de de ou de
        abc.
mysql>SELECT "pi" REGEXP "pi|apa"; -> 1mysql>SELECT "axe" REGEXP "pi|apa"; -> 0mysql>SELECT "apa" REGEXP "pi|apa"; -> 1mysql>SELECT "apa" REGEXP "^(pi|apa)$"; -> 1mysql>SELECT "pi" REGEXP "^(pi|apa)$"; -> 1mysql>SELECT "pix" REGEXP "^(pi|apa)$"; -> 0
        (abc)*
      
        Correspond à zéro ou plus séquences de
        abc.
mysql>SELECT "pi" REGEXP "^(pi)*$"; -> 1mysql>SELECT "pip" REGEXP "^(pi)*$"; -> 0mysql>SELECT "pipi" REGEXP "^(pi)*$"; -> 1
        {1}, {2,3}
      
        Voici une fa¸on plus générale d'écrire les expressions
        régulières qui correspondent à plusieurs occurrences du
        dernier atome. m et n sont
        des entiers.
      
            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 arguments doivent être compris entre
        0 et RE_DUP_MAX (par
        défaut 255), inclusif. S'il y a deux arguments, le second doit
        être supérieur ou égal au premier.
      
mysql>SELECT 'abcde' REGEXP 'a[bcd]{2}e'; -> 0mysql>SELECT 'abcde' REGEXP 'a[bcd]{3}e'; -> 1mysql>SELECT 'abcde' REGEXP 'a[bcd]{1,10}e'; -> 1
        [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 littéral
        ], il doit suivre immédiatement le crochet
        ouvrant [. Pour inclure le caractère
        litté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]'; -> 1mysql>SELECT 'aXbc' REGEXP '^[a-dXYZ]$'; -> 0mysql>SELECT 'aXbc' REGEXP '^[a-dXYZ]+$'; -> 1mysql>SELECT 'aXbc' REGEXP '^[^a-dXYZ]+$'; -> 0mysql>SELECT 'gheis' REGEXP '^[^a-dXYZ]+$'; -> 1mysql>SELECT 'gheisa' REGEXP '^[^a-dXYZ]+$'; -> 0
        [.characters.]
      
        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. Vous trouverez la liste complète des noms de
        caractères dans regexp/cname.h.
      
mysql>SELECT '~' REGEXP '[[.~.]]'; -> 1mysql>SELECT '~' REGEXP '[[.tilde.]]'; -> 1
        [=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.
      
        [:character_class:]
      
        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 :
      
| alnum | Caractères alpha-numériques | 
| alpha | Caractères alphabétiques | 
| blank | Caractères espace | 
| cntrl | Caractères de contrôle | 
| digit | Chiffres | 
| graph | Caractères graphiques | 
| lower | Minuscules | 
| print | Caractères graphiques ou espaces | 
| punct | Ponctuation | 
| space | Espace, tabulation, nouvelle ligne et retour chariot | 
| upper | Majuscules | 
| xdigit | Chiffres hexadécimaux | 
        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:]]+"; -> 1mysql>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[[:>:]]'; -> 1mysql>SELECT 'a xword a' REGEXP '[[:<:]]word[[:>:]]'; -> 0
    Pour utiliser une instance littérale d'un caractère spécial dans
    une expression régulière, vous devez la faire précéder de deux
    caractères anti-slash. L'analyseur MySQL interpréte le premier
    anti-slash, et la bibliothèque d'expressions régulières utilisera
    le second. Par exemple, pour rechercher l'expression
    1+2 qui contient le caractère spécial
    +, seule la dernière expression régulière sera
    correcte :
  
mysql>SELECT '1+2' REGEXP '1+2'; -> 0mysql>SELECT '1+2' REGEXP '1\+2'; -> 0mysql>SELECT '1+2' REGEXP '1\\+2'; -> 1