Dans MariaDB, le REGEXP L'opérateur est utilisé pour déterminer si une chaîne correspond ou non à une expression régulière.
Si la chaîne correspond à l'expression régulière fournie, le résultat est 1 , sinon c'est 0 .
Syntaxe
La syntaxe ressemble à ceci :
expr REGEXP pat
Où expr est la chaîne d'entrée et pat est l'expression régulière pour laquelle vous testez la chaîne.
Exemples
Vous trouverez ci-dessous des exemples d'utilisation de REGEXP opérateur avec différents motifs.
Expression régulière de base
Commençons par l'exemple le plus simple. L'expression régulière la plus simple que nous puissions utiliser est celle qui ne contient aucun caractère spécial. Ici, nous utilisons simplement une chaîne. Si une partie de la chaîne d'entrée correspond à cette chaîne, elle renvoie une correspondance.
SELECT
'Corn' REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP 'Corn' AS "Acorn",
'Corner' REGEXP 'Corn' AS "Corner",
'Cheese' REGEXP 'Corn' AS "Cheese";Résultat :
+------+-------+--------+--------+ | Corn | Acorn | Corner | Cheese | +------+-------+--------+--------+ | 1 | 1 | 1 | 0 | +------+-------+--------+--------+
Reconnaître le début d'une chaîne
Dans cet exemple, l'expression régulière spécifie que la chaîne doit commencer par Co .
SELECT
'Corn' REGEXP '^Co' AS "Corn",
'Acorn' REGEXP '^Co' AS "Acorn",
'Cheese' REGEXP '^Co' AS "Cheese";Résultat :
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 0 | 0 | +------+-------+--------+
Reconnaître la fin d'une chaîne
Dans cet exemple, l'expression régulière spécifie que la chaîne doit se terminer par rn .
SELECT
'Corn' REGEXP 'rn$' AS "Corn",
'Acorn' REGEXP 'rn$' AS "Acorn",
'Cheese' REGEXP 'rn$' AS "Cheese";Résultat :
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 1 | 0 | +------+-------+--------+
Correspondre à n'importe quel caractère
Le . caractère correspond à n'importe quel caractère.
SELECT
'Corn' REGEXP '.' AS "Corn",
'Cheese' REGEXP '.' AS "Cheese",
'' REGEXP '.' AS "";Résultat :
+------+--------+---+ | Corn | Cheese | | +------+--------+---+ | 1 | 1 | 0 | +------+--------+---+
Ce caractère est généralement utilisé conjointement avec d'autres caractères pour spécifier d'autres critères. Par exemple :
SELECT
'Corn' REGEXP '^C.rn$' AS "Corn",
'Crn' REGEXP '^C.rn$' AS "Crn";Résultat :
+------+-----+ | Corn | Crn | +------+-----+ | 1 | 0 | +------+-----+
Ici, nous spécifions que la chaîne doit commencer par C , qu'il doit être suivi d'un caractère (n'importe quel caractère) et qu'il doit se terminer par rn .
Notez que ce caractère spécifie une seule instance du caractère. Si vous souhaitez spécifier plusieurs instances (par exemple ee au lieu de simplement e ), vous devrez ajouter plus de . caractères.
SELECT
'Tweet' REGEXP '^Tw..t$' AS "Tweet",
'Tweat' REGEXP '^Tw..t$' AS "Tweat",
'Tweet' REGEXP '^Tw.t$' AS "Tweet",
'Twit' REGEXP '^Tw..t$' AS "Twit";Résultat :
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Une autre façon de procéder consiste à spécifier le nombre d'occurrences entre accolades :
SELECT
'Tweet' REGEXP '^Tw.{2}t$' AS "Tweet",
'Tweat' REGEXP '^Tw.{2}t$' AS "Tweat",
'Tweet' REGEXP '^Tw.{1}t$' AS "Tweet",
'Twit' REGEXP '^Tw.{2}t$' AS "Twit";Résultat :
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Cependant, si vous connaissez le caractère que vous recherchez, vous pouvez spécifier ce caractère (au lieu du . caractère), comme illustré dans l'exemple suivant.
Match zéro ou plusieurs instances d'un caractère spécifique
Nous pouvons faire ce qui suit pour spécifier zéro ou plusieurs instances du e caractère :
SELECT
'Twet' REGEXP '^Twe*t$' AS "Twet",
'Tweet' REGEXP '^Twe*t$' AS "Tweet",
'Tweeet' REGEXP '^Twe*t$' AS "Tweeet",
'Twt' REGEXP '^Twe*t$' AS "Twt",
'Twit' REGEXP '^Twe*t$' AS "Twit",
'Twiet' REGEXP '^Twe*t$' AS "Twiet",
'Tweit' REGEXP '^Twe*t$' AS "Tweit";Résultat :
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Les quatre premiers correspondent mais pas les trois derniers.
Faites correspondre une ou plusieurs instances d'un personnage spécifique
Nous pouvons modifier l'exemple précédent afin de n'obtenir une correspondance que si une ou plusieurs caractères sont trouvés (l'exemple précédent renvoyait une correspondance si zéro ou plus ont été trouvés). Pour ce faire, nous utilisons simplement + au lieu de * :
SELECT
'Twet' REGEXP '^Twe+t$' AS "Twet",
'Tweet' REGEXP '^Twe+t$' AS "Tweet",
'Tweeet' REGEXP '^Twe+t$' AS "Tweeet",
'Twt' REGEXP '^Twe+t$' AS "Twt",
'Twit' REGEXP '^Twe+t$' AS "Twit",
'Twiet' REGEXP '^Twe+t$' AS "Twiet",
'Tweit' REGEXP '^Twe+t$' AS "Tweit";Résultat :
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 0 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Dans ce cas, le quatrième mot renvoie un résultat différent de l'exemple précédent.
Match zéro ou une instance d'un caractère spécifique
Nous pouvons modifier l'exemple précédent afin d'obtenir uniquement une correspondance sur zéro ou sur l'un des caractères souhaités. Pour ce faire, nous utilisons ? :
SELECT
'Twet' REGEXP '^Twe?t$' AS "Twet",
'Tweet' REGEXP '^Twe?t$' AS "Tweet",
'Tweeet' REGEXP '^Twe?t$' AS "Tweeet",
'Twt' REGEXP '^Twe?t$' AS "Twt",
'Twit' REGEXP '^Twe?t$' AS "Twit",
'Twiet' REGEXP '^Twe?t$' AS "Twiet",
'Tweit' REGEXP '^Twe?t$' AS "Tweit";Résultat :
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 0 | 0 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Alternance
Vous pouvez utiliser le | caractère pour correspondre à l'une ou l'autre suite de caractères :
SELECT
'Tweet' REGEXP 'Tw|et' AS "Tweet",
'For Let' REGEXP 'Tw|et' AS "For Let",
'Banana' REGEXP 'Tw|et' AS "Banana";Résultat :
+-------+---------+--------+ | Tweet | For Let | Banana | +-------+---------+--------+ | 1 | 1 | 0 | +-------+---------+--------+
Voici un autre exemple où je recherche des mots entiers :
SELECT
'Cat' REGEXP 'Cat|Dog' AS "Cat",
'Dog' REGEXP 'Cat|Dog' AS "Dog",
'Doggone' REGEXP 'Cat|Dog' AS "Doggone",
'Banana' REGEXP 'Cat|Dog' AS "Banana";Résultat :
+-----+-----+---------+--------+ | Cat | Dog | Doggone | Banana | +-----+-----+---------+--------+ | 1 | 1 | 1 | 0 | +-----+-----+---------+--------+
Nous obtenons toujours une correspondance même lorsque notre expression régulière ne correspond qu'à une partie de la chaîne.
Match zéro ou plusieurs instances d'une séquence
Vous pouvez utiliser des crochets avec l'astérisque ()* pour spécifier zéro ou plusieurs instances d'une séquence :
SELECT
'Banana' REGEXP '(an)*' AS "Banana",
'Land' REGEXP '(an)*' AS "Land",
'Cheese' REGEXP '(an)*' AS "Cheese";Résultat :
+--------+------+--------+ | Banana | Land | Cheese | +--------+------+--------+ | 1 | 1 | 1 | +--------+------+--------+
Autre exemple :
SELECT
'Banana' REGEXP '^B(an)*d$' AS "Banana",
'Band' REGEXP '^B(an)*d$' AS "Band",
'Bald' REGEXP '^B(an)*d$' AS "Bald",
'Bad' REGEXP '^B(an)*d$' AS "Bad";Résultat :
+--------+------+------+-----+ | Banana | Band | Bald | Bad | +--------+------+------+-----+ | 0 | 1 | 0 | 0 | +--------+------+------+-----+
Répétition
Comme vu dans un exemple précédent, vous pouvez utiliser des accolades pour spécifier la répétition. Cette notation fournit une manière plus générale d'écrire des expressions régulières que certains des exemples précédents :
SELECT
'Tweeet' REGEXP 'e{3}' AS "Tweeet",
'Tweet' REGEXP 'e{3}' AS "Tweet";Résultat :
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Plage
Vous pouvez utiliser le trait d'union pour spécifier une plage. Voici un exemple qui spécifie une plage de nombres :
SELECT
'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";Résultat :
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Et l'exemple suivant spécifie une plage de lettres :
SELECT
'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
'ABC' REGEXP '[A-Z]' AS "ABC",
'123' REGEXP '[A-Z]' AS "123";Résultat :
+-----------+-----+-----+ | Tweet 123 | ABC | 123 | +-----------+-----+-----+ | 1 | 1 | 0 | +-----------+-----+-----+
Voici ce qui se passe si nous limitons la plage de nombres :
SELECT
'123' REGEXP '[1-3]' AS "123",
'012' REGEXP '[1-3]' AS "012",
'045' REGEXP '[1-3]' AS "045";Résultat :
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 1 | 1 | 0 | +-----+-----+-----+
Pas dans une plage
Nous pouvons utiliser le ^ caractère pour modifier l'exemple précédent afin d'exclure la plage de caractères spécifiée :
SELECT
'123' REGEXP '[^1-3]' AS "123",
'012' REGEXP '[^1-3]' AS "012",
'045' REGEXP '[^1-3]' AS "045";Résultat :
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 0 | 1 | 1 | +-----+-----+-----+
Dans ce cas, nous obtenons le résultat opposé à l'exemple précédent.
Valeurs nulles
Si l'expression ou le modèle est null , le résultat est null :
SELECT
null REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP null AS "Acorn",
null REGEXP null AS "Corner";Résultat :
+------+-------+--------+ | Corn | Acorn | Corner | +------+-------+--------+ | NULL | NULL | NULL | +------+-------+--------+
