Comment REGEXP_REPLACE() fonctionne dans MariaDB

Dans MariaDB, le REGEXP_REPLACE() La fonction remplace les occurrences de la sous-chaîne dans une chaîne qui correspond au modèle d'expression régulière donné.

La chaîne entière est renvoyée avec les remplacements.

S'il n'y a pas de correspondance (c'est-à-dire que la chaîne d'entrée ne contient pas la sous-chaîne), la chaîne entière est renvoyée inchangée.

Syntaxe

La syntaxe ressemble à ceci :

REGEXP_REPLACE(subject, pattern, replace)

Où subject est la chaîne d'entrée, pattern est le modèle d'expression régulière pour la sous-chaîne, et replace est la chaîne de remplacement.

Notez qu'au moment de la rédaction, la version de MariaDB de REGEXP_REPLACE() accepte moins d'arguments que REGEXP_REPLACE() de MySQL une fonction. La version de MySQL vous permet de fournir des arguments pour la position de départ de la recherche, l'occurrence à rechercher, ainsi qu'un moyen d'affiner l'expression régulière avec le type de correspondance.

Exemple

Voici un exemple basique d'utilisation de REGEXP_REPLACE() dans MariaDB :

SELECT REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird');

Résultat :

+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird') |
+------------------------------------------------+
| Cats and birds                                 |
+------------------------------------------------+

Dans ce cas, il y a correspondance et la sous-chaîne est remplacée par la chaîne de remplacement.

Les expressions régulières peuvent être très puissantes, et cet exemple utilise un exemple très simple. Pour utiliser REGEXP_REPLACE() efficacement, vous aurez besoin de connaître le modèle correct à utiliser pour le résultat souhaité.

Plusieurs correspondances

Voici un exemple avec plusieurs correspondances :

SELECT REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird');

Résultat :

+----------------------------------------------------------+
| REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird') |
+----------------------------------------------------------+
| My bird likes other birds                                |
+----------------------------------------------------------+

Aucune correspondance

Voici un exemple où il n'y a pas de correspondance :

SELECT REGEXP_REPLACE('Cats and dogs', 't.g', 'bird');

Résultat :

+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 't.g', 'bird') |
+------------------------------------------------+
| Cats and dogs                                  |
+------------------------------------------------+

Il n'y a pas de correspondance, donc la chaîne d'origine est renvoyée inchangée.

Sensibilité à la casse

Le REGEXP_REPLACE() suit les règles de sensibilité à la casse du classement effectif. La correspondance est effectuée de manière insensible à la casse pour les classements insensibles à la casse, et sensible à la casse pour les classements sensibles à la casse et pour les données binaires.

Voici un exemple :

SELECT 
    REGEXP_REPLACE('My Cats', 'c.t', 'dog') AS "My Default",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, 'c.t', 'dog') AS "Case Insensitive",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, 'c.t', 'dog') AS "Case Sensitive";

Résultat :

+------------+------------------+----------------+
| My Default | Case Insensitive | Case Sensitive |
+------------+------------------+----------------+
| My dogs    | My dogs          | My Cats        |
+------------+------------------+----------------+

Mon classement par défaut est insensible à la casse. Les deux autres chaînes ont été forcées respectivement à un classement insensible à la casse et à un classement sensible à la casse.

Fournir un BINARY La chaîne est également sensible à la casse (nous en reparlerons plus tard).

Ignorer la sensibilité à la casse

La sensibilité à la casse du classement peut être remplacée à l'aide de (?i ) et (?-i ) Indicateurs PCRE.

Voici l'exemple précédent, mais cette fois en utilisant le (?-i) drapeau sur chaque motif pour forcer la sensibilité à la casse :

SELECT 
    REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "My Default",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, '(?-i)c.t', 'dog') AS "Case Insensitive",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, '(?-i)c.t', 'dog') AS "Case Sensitive";

Résultat :

+------------+------------------+----------------+
| My Default | Case Insensitive | Case Sensitive |
+------------+------------------+----------------+
| My Cats    | My Cats          | My Cats        |
+------------+------------------+----------------+

Et ici, il utilise le (?i) drapeau pour forcer l'insensibilité à la casse :

SELECT 
    REGEXP_REPLACE('My Cats', '(?i)c.t', 'dog') AS "My Default",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, '(?i)c.t', 'dog') AS "Case Insensitive",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, '(?i)c.t', 'dog') AS "Case Sensitive";

Résultat :

+------------+------------------+----------------+
| My Default | Case Insensitive | Case Sensitive |
+------------+------------------+----------------+
| My dogs    | My dogs          | My dogs        |
+------------+------------------+----------------+

Chaînes binaires

Passer un BINARY chaîne affecte également la sensibilité à la casse. Avec BINARY chaînes, un caractère majuscule est différent de son homologue minuscule :

Exemple :

SELECT 
    REGEXP_REPLACE('My Cats', 'c.t', 'dog') AS "Character",
    REGEXP_REPLACE(BINARY 'My Cats', 'c.t', 'dog') AS "Binary";

Résultat :

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My dogs   | My Cats |
+-----------+---------+

Voici ce qui se passe si nous changeons la casse :

SELECT 
    REGEXP_REPLACE('My Cats', 'C.t', 'dog') AS "Character",
    REGEXP_REPLACE(BINARY 'My Cats', 'C.t', 'dog') AS "Binary";

Résultat :

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My dogs   | My dogs |
+-----------+---------+

Sensibilité à la casse sur BINARY les chaînes peuvent également être remplacées par le (?-i) et (?i) Indicateurs PCRE :

SELECT 
    REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "Character",
    REGEXP_REPLACE(BINARY 'My Cats', '(?-i)c.t', 'dog') AS "Binary";

Résultat :

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My Cats   | My Cats |
+-----------+---------+

Arguments nuls

Passer null car tout argument donne null :

SELECT 
    REGEXP_REPLACE(null, 'c.t', 'dog') AS "1",
    REGEXP_REPLACE('Cat', null, 'dog') AS "2",
    REGEXP_REPLACE('Cat', 'c.t', null) AS "3",
    REGEXP_REPLACE(null, null, null) AS "4";

Résultat :

+------+------+------+------+
| 1    | 2    | 3    | 4    |
+------+------+------+------+
| NULL | NULL | NULL | NULL |
+------+------+------+------+

Mauvais nombre d'arguments

Passer le mauvais nombre d'arguments ou aucun argument, entraîne une erreur :

SELECT REGEXP_REPLACE();

Résultat :

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'REGEXP_REPLACE'