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

REGEXP_LIKE¶

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

REGEXP_LIKE est similaire à la fonction LIKE, mais avec les expressions régulières étendues `POSIX<http://en.wikipedia.org/wiki/Regular_expression#POSIX_basic_and_extended>`_ au lieu de la syntaxe de modèle SQL LIKE. REGEXP_LIKE 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:: RLIKE (1ère syntaxe)

Syntaxe¶

REGEXP_LIKE( <subject> , <pattern> [ , <parameters> ] )

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`	Le caractère générique `.` du mode à une ligne POSIX correspond à `\n`

Par défaut : c

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

Renvoie¶

Renvoie une valeur BOOLEAN ou NULL :

Renvoie TRUE s’il existe une correspondance.
Renvoie FALSE s’il n’y a pas de correspondance.
Renvoie NULL si l’un des arguments est NULL.

Notes sur l’utilisation¶

La fonction ancre implicitement un motif aux deux extrémités (par exemple, '' devient automatiquement '^$' et 'ABC' devient automatiquement '^ABC$'). Par exemple, pour faire correspondre n’importe quelle chaîne commençant par ABC, le modèle serait 'ABC.*'.
Le caractère barre oblique inverse (\) est le caractère d’échappement. Pour plus d’informations, voir Spécification d’expressions régulières dans des constantes de chaîne entre guillemets simples.
Pour plus de notes sur l’utilisation, voir Notes générales sur l’utilisation pour les fonctions d’expression régulière.

Détails du classement¶

Arguments with collation specifications currently aren’t supported.

Exemples¶

Les exemples suivants utilisent la fonction REGEXP_LIKE :

Exécuter des requêtes d’expressions régulières de base sur des chaînes
Exécution de requêtes d’expressions régulières sur des chaînes comportant des caractères spéciaux

Pour des exemples supplémentaires d’expressions régulières, consultez REGEXP.

Exécuter des requêtes d’expressions régulières de base sur des chaînes¶

Créer une table avec les noms des villes :

CREATE OR REPLACE TABLE cities(city VARCHAR(20));

INSERT INTO cities VALUES
  ('Sacramento'),
  ('San Francisco'),
  ('San Luis Obispo'),
  ('San Jose'),
  ('Santa Barbara'),
  ('Palo Alto'),
  (NULL);

Copy

Vous pouvez utiliser .* comme caractère générique pour faire correspondre autant de caractères que possible. L’exemple suivant correspond au modèle Fran n’importe où dans la valeur de chaîne :

SELECT * FROM cities WHERE REGEXP_LIKE(city, '.*Fran.*');

Copy

+---------------+
| CITY          |
|---------------|
| San Francisco |
+---------------+

L’exemple suivant utilise le paramètre i pour une correspondance non sensible à la casse :

SELECT * FROM cities WHERE REGEXP_LIKE(city, '.*fran.*', 'i');

Copy

+---------------+
| CITY          |
|---------------|
| San Francisco |
+---------------+

Pour trouver un modèle qui correspond au début d’une valeur de chaîne, exécutez une requête qui utilise un caractère générique :

SELECT * FROM cities WHERE REGEXP_LIKE(city, 'san.*', 'i');

Copy

+-----------------+
| CITY            |
|-----------------|
| San Francisco   |
| San Luis Obispo |
| San Jose        |
| Santa Barbara   |
+-----------------+

Pour exécuter une requête sensible à la casse avec un caractère générique, omettez le paramètre i :

SELECT * FROM cities WHERE REGEXP_LIKE(city, 'san.*');

Copy

+------+
| CITY |
|------|
+------+

Vous pouvez utiliser le métacaractère \w+ pour une correspondance avec un mot et un métacaractère \s pour une correspondance avec un caractère d’espacement, tel qu’un espace ou une tabulation. La requête suivante recherche les valeurs qui incluent un mot, suivi d’un caractère d’espace, suivi d’un mot :

SELECT * FROM cities WHERE REGEXP_LIKE(city, '\\w+\\s\\w+');

Copy

+---------------+
| CITY          |
|---------------|
| San Francisco |
| San Jose      |
| Santa Barbara |
| Palo Alto     |
+---------------+

La sortie de la requête n’inclut pas San Luis Obispo car cette valeur comporte trois mots avec un espace entre les premier et deuxième mots au lieu de seulement deux mots avec un espace entre eux.

Dans une expression régulière, vous pouvez souvent utiliser un métacaractère majuscule pour ignorer la signification d’un métacaractère en minuscule. Par exemple, exécutez une requête qui recherche les valeurs qui n’incluent pas de caractère d’espace entre deux mots en utilisant le métacaractère \S :

SELECT * FROM cities WHERE REGEXP_LIKE(city, '\\w+\\S\\w+');

Copy

+------------+
| CITY       |
|------------|
| Sacramento |
+------------+

Exécution de requêtes d’expressions régulières sur des chaînes comportant des caractères spéciaux¶

Les exemples de cette section recherchent des valeurs avec des caractères spéciaux, qui sont des caractères autres que az, AZ, trait de soulignement (« _ »), ou chiffre décimal.

Pour rechercher un métacaractère, effectuez l’échappement du métacaractère. Pour plus d’informations, voir Spécification d’expressions régulières dans des constantes de chaîne entre guillemets simples.

Créez une table, puis insérez des valeurs avec des caractères spéciaux :

CREATE OR REPLACE TABLE regex_special_characters(v VARCHAR(20));

INSERT INTO regex_special_characters VALUES
  ('Snow'),
  ('Sn.ow'),
  ('Sn@ow'),
  ('Sn$ow'),
  ('Sn\\ow');

Copy

La première valeur insérée ne contient pas de caractères spéciaux.

Interrogez la table pour afficher les données :

SELECT * FROM regex_special_characters;

Copy

+-------+
| V     |
|-------|
| Snow  |
| Sn.ow |
| Sn@ow |
| Sn$ow |
| Sn\ow |
+-------+

Vous pouvez rechercher n’importe quel caractère spécial en utilisant la séquence barre oblique inverse Perl \W, qui recherche les caractères qui ne sont pas des caractères de type « mot ». Par exemple, la requête suivante recherche les valeurs de la table qui comportent des caractères spéciaux :

SELECT *
  FROM regex_special_characters
  WHERE REGEXP_LIKE(v, '.*\\W.*');

Copy

+-------+
| V     |
|-------|
| Sn.ow |
| Sn@ow |
| Sn$ow |
| Sn\ow |
+-------+

Pour rechercher des métacaractères dans une constante de chaîne entre guillemets simples, vous devez effectuer un échappement du métacaractère avec deux barres obliques inverses. Par exemple, la requête suivante recherche les valeurs qui contiennent le métacaractère $ :

SELECT *
  FROM regex_special_characters
  WHERE REGEXP_LIKE(v, '.*\\$.*');

Copy

+-------+
| V     |
|-------|
| Sn$ow |
+-------+

Si vous recherchez une barre oblique inverse, un caractère d’échappement de barre oblique inverse supplémentaire est nécessaire. Par exemple, la requête suivante recherche les valeurs qui contiennent \ ou le métacaractère . :

SELECT *
  FROM regex_special_characters
  WHERE REGEXP_LIKE(v, '.*(\\.|\\\\).*');

Copy

+-------+
| V     |
|-------|
| Sn.ow |
| Sn\ow |
+-------+