Catégories :

Fonctions de chaîne (expressions régulières)

[ NOT ] RLIKE

Effectue une comparaison pour déterminer si une chaîne correspond ou non à un modèle spécifié. Les deux entrées doivent être des expressions textuelles.

RLIKE est similaire à la fonction [ NOT ] LIKE, mais avec des expressions régulières étendues POSIX au lieu de la syntaxe de modèle SQL LIKE. Il prend en charge des conditions de correspondance plus complexes que LIKE.

Astuce

Vous pouvez utiliser le service d’optimisation de recherche pour améliorer les performances des requêtes qui appellent cette fonction. Pour plus de détails, voir Service d’optimisation de la recherche.

Alias:

[ NOT ] REGEXP (2e syntaxe) , REGEXP_LIKE (1ère syntaxe)

Voir aussi : Fonctions de chaîne (expressions régulières)

Syntaxe

-- 1st syntax
RLIKE( <subject> , <pattern> [ , <parameters> ] )

-- 2nd syntax
<subject> [ NOT ] RLIKE <pattern>
Copy

Arguments

Obligatoire :

subject

La chaîne à rechercher pour les correspondances.

pattern

Modèle devant correspondre.

Pour des directives sur la spécification des modèles, voir Fonctions de chaîne (expressions régulières).

Facultatif :

parameters

Chaîne d’un ou plusieurs caractères spécifiant les paramètres utilisés pour la recherche de correspondances. Valeurs prises en charge :

Paramètre

Description

c

Correspondance sensible à la casse

i

Correspondance non sensible à la casse

m

Mode multiligne

e

Extraire les sous-correspondances.

s

POSIX wildcard character . matches \n

Par défaut : c

Pour plus de détails, voir Spécification des paramètres de l’expression régulière.

Renvoie

Renvoie un BOOLEAN ou un NULL.

  • Lorsque RLIKE est spécifié, la valeur est TRUE s’il y a une correspondance. Sinon, renvoie FALSE.

  • Lorsque NOT RLIKE est spécifié, la valeur est TRUE s’il n’y a pas de correspondance. Sinon, renvoie FALSE.

  • Lorsque RLIKE ou NOT RLIKE est spécifié, renvoie NULL si l’un des arguments est NULL.

Notes sur l’utilisation

Détails du classement

Arguments with collation specifications are currently not supported.

Exemples

Exécutez les commandes suivantes afin de définir les données pour les exemples de cette rubrique :

CREATE OR REPLACE TABLE rlike_ex(city VARCHAR(20));
INSERT INTO rlike_ex VALUES ('Sacramento'), ('San Francisco'), ('San Jose'), (null);
Copy

Exemples qui utilisent la première syntaxe

Les exemples suivants cherchent une correspondance de modèles insensible à la casse avec des caractères génériques :

SELECT * FROM rlike_ex WHERE RLIKE(city, 'san.*', 'i');
Copy
+---------------+
| CITY          |
|---------------|
| San Francisco |
| San Jose      |
+---------------+

SELECT * FROM rlike_ex WHERE NOT RLIKE(city, 'san.*', 'i');
Copy
+------------+
| CITY       |
|------------|
| Sacramento |
+------------+

Les exemples suivants déterminent si une chaîne correspond au format d’un numéro de téléphone et d’une adresse e-mail. Dans ces exemples, les expressions régulières sont spécifiées dans des chaînes comprises entre des dollars pour éviter l’échappement des barres obliques inverses dans l’expression régulière.

SELECT RLIKE('800-456-7891',
             $$[2-9]\d{2}-\d{3}-\d{4}$$) AS matches_phone_number;
Copy
+----------------------+
| MATCHES_PHONE_NUMBER |
|----------------------|
| True                 |
+----------------------+

SELECT RLIKE('jsmith@email.com',
             $$\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$$) AS matches_email_address;
Copy
+-----------------------+
| MATCHES_EMAIL_ADDRESS |
|-----------------------|
| True                  |
+-----------------------+

Les exemples suivants cherchent les mêmes correspondances, mais utilisent les constantes de chaîne entre guillemets simples pour spécifier les expressions régulières.

Comme l’exemple utilise des constantes de chaîne entre guillemets simples, chaque barre oblique inverse doit être échappée avec une autre barre oblique inverse.

SELECT RLIKE('800-456-7891',
             '[2-9]\\d{2}-\\d{3}-\\d{4}') AS matches_phone_number;
Copy
+----------------------+
| MATCHES_PHONE_NUMBER |
|----------------------|
| True                 |
+----------------------+

SELECT RLIKE('jsmith@email.com',
             '\\w+@[a-zA-Z_]+?\\.[a-zA-Z]{2,3}') AS matches_email_address;
Copy
+-----------------------+
| MATCHES_EMAIL_ADDRESS |
|-----------------------|
| True                  |
+-----------------------+

Sinon, réécrivez les instructions et évitez les séquences qui reposent sur le caractère barre oblique inverse.

SELECT RLIKE('800-456-7891',
             '[2-9][0-9]{2}-[0-9]{3}-[0-9]{4}') AS matches_phone_number;
Copy
+----------------------+
| MATCHES_PHONE_NUMBER |
|----------------------|
| True                 |
+----------------------+

SELECT RLIKE('jsmith@email.com',
             '[a-zA-Z_]+@[a-zA-Z_]+?\\.[a-zA-Z]{2,3}') AS matches_email_address;
Copy
+-----------------------+
| MATCHES_EMAIL_ADDRESS |
|-----------------------|
| True                  |
+-----------------------+

Exemples qui utilisent la deuxième syntaxe

L’exemple suivant cherche une correspondance de motifs insensible à la casse avec des caractères génériques :

SELECT * FROM rlike_ex WHERE city RLIKE 'San.* [fF].*';
Copy
+---------------+
| CITY          |
|---------------|
| San Francisco |
+---------------+

Exemples supplémentaires

Pour des exemples supplémentaires d’expressions régulières, voir [ NOT ] REGEXP.

Langage: Français