Hoe REGEXP_REPLACE() werkt in MariaDB

In MariaDB, de REGEXP_REPLACE() functie vervangt de subtekenreeks binnen een tekenreeks die overeenkomt met het gegeven patroon voor reguliere expressies.

De hele string wordt geretourneerd samen met de vervangingen.

Als er geen overeenkomst is (d.w.z. de invoertekenreeks bevat niet de subtekenreeks), wordt de hele tekenreeks ongewijzigd geretourneerd.

Syntaxis

De syntaxis gaat als volgt:

REGEXP_REPLACE(subject, pattern, replace)

Waar subject is de invoerreeks, pattern is het reguliere expressiepatroon voor de substring, en replace is de vervangende string.

Merk op dat, op het moment van schrijven, MariaDB's versie van REGEXP_REPLACE() accepteert minder argumenten dan MySQL's REGEXP_REPLACE() functie. Met de versie van MySQL kunt u argumenten opgeven voor de startpositie van de zoekopdracht, naar welke instantie moet worden gezocht, evenals een manier om de reguliere expressie te verfijnen met het zoektype.

Voorbeeld

Hier is een eenvoudig voorbeeld van het gebruik van REGEXP_REPLACE() in MariaDB:

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

Resultaat:

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

In dit geval is er een overeenkomst en wordt de substring vervangen door de vervangende string.

Reguliere expressies kunnen erg krachtig zijn, en in dit voorbeeld wordt een heel eenvoudig voorbeeld gebruikt. Om REGEXP_REPLACE() . te gebruiken effectief is, moet u het juiste patroon kennen om te gebruiken voor het gewenste resultaat.

Meerdere wedstrijden

Hier is een voorbeeld met meerdere overeenkomsten:

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

Resultaat:

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

Geen overeenkomst

Hier is een voorbeeld waarbij er geen overeenkomst is:

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

Resultaat:

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

Er is geen overeenkomst, dus de oorspronkelijke tekenreeks wordt ongewijzigd geretourneerd.

Hoofdlettergevoeligheid

De REGEXP_REPLACE() functie volgt de hoofdlettergevoeligheidsregels van de effectieve sortering. Het matchen wordt hoofdletterongevoelig uitgevoerd voor hoofdletterongevoelige sorteringen en hoofdlettergevoelig voor hoofdlettergevoelige sorteringen en voor binaire gegevens.

Hier is een voorbeeld:

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";

Resultaat:

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

Mijn standaardsortering is niet hoofdlettergevoelig. De andere twee strings werden gedwongen om respectievelijk hoofdlettergevoelig en hoofdlettergevoelig te sorteren.

Het verstrekken van een BINARY string is ook hoofdlettergevoelig (hierover later meer).

Hoofdlettergevoeligheid overschrijven

De hoofdlettergevoeligheid van de sortering kan worden overschreven met de (?i ) en (?-i ) PCRE-vlaggen.

Hier is het vorige voorbeeld, maar deze keer met de (?-i) vlag op elk patroon om hoofdlettergevoeligheid te forceren:

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";

Resultaat:

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

En hier gebruikt het de (?i) vlag om hoofdletterongevoeligheid te forceren:

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";

Resultaat:

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

Binaire strings

Een BINARY doorgeven string heeft ook invloed op de hoofdlettergevoeligheid. Met BINARY strings, is een hoofdletter anders dan zijn tegenhanger in kleine letters:

Voorbeeld:

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

Resultaat:

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

Dit is wat er gebeurt als we de zaak wijzigen:

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

Resultaat:

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

Hoofdlettergevoeligheid op BINARY tekenreeksen kunnen ook worden overschreven met de (?-i) en (?i) PCRE-vlaggen:

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

Resultaat:

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

Nullargumenten

Doorgeven van null aangezien elk argument resulteert in 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";

Resultaat:

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

Onjuist aantal argumenten

Het doorgeven van het verkeerde aantal argumenten of geen argumenten, resulteert in een fout:

SELECT REGEXP_REPLACE();

Resultaat:

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