Hur REGEXP_REPLACE() fungerar i MariaDB

I MariaDB, REGEXP_REPLACE() funktion ersätter förekomster av delsträngen i en sträng som matchar det givna reguljära uttrycksmönstret.

Hela strängen returneras tillsammans med ersättningarna.

Om det inte finns någon matchning (dvs. inmatningssträngen innehåller inte delsträngen), returneras hela strängen oförändrad.

Syntax

Syntaxen ser ut så här:

REGEXP_REPLACE(subject, pattern, replace)

Där subject är inmatningssträngen, pattern är det reguljära uttrycksmönstret för delsträngen och replace är ersättningssträngen.

Observera att i skrivande stund MariaDBs version av REGEXP_REPLACE() accepterar färre argument än MySQL:s REGEXP_REPLACE() fungera. MySQL:s version låter dig ange argument för sökningens startposition, vilken förekomst du ska söka efter, samt ett sätt att förfina det reguljära uttrycket med matchningstyp.

Exempel

Här är ett grundläggande exempel på hur du använder REGEXP_REPLACE() i MariaDB:

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

Resultat:

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

I det här fallet finns det en matchning och delsträngen ersätts med ersättningssträngen.

Reguljära uttryck kan vara mycket kraftfulla, och det här exemplet använder ett mycket enkelt exempel. För att använda REGEXP_REPLACE() i praktiken måste du känna till det korrekta mönstret att använda för det önskade resultatet.

Flera matchningar

Här är ett exempel med flera matchningar:

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

Resultat:

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

Ingen match

Här är ett exempel där det inte finns någon matchning:

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

Resultat:

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

Det finns ingen matchning, så den ursprungliga strängen returneras oförändrad.

Skaftkänslighet

REGEXP_REPLACE() funktionen följer reglerna för skiftlägeskänslighet för den effektiva sorteringen. Matchning utförs skiftlägesokänsligt för skiftlägesokänsliga sorteringar och skiftlägeskänsliga för skiftlägeskänsliga sorteringar och för binära data.

Här är ett exempel:

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

Resultat:

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

Min standardsortering är skiftlägesokänslig. De andra två strängarna tvingades till en skiftlägesokänslig sortering respektive skiftlägeskänslig.

Tillhandahålla en BINARY sträng är också skiftlägeskänslig (mer om detta senare).

Åsidosätt skiftlägeskänslighet

Sorteringens skiftlägeskänslighet kan åsidosättas med hjälp av (?i ) och (?-i ) PCRE-flaggor.

Här är det tidigare exemplet, men den här gången använder du (?-i) flagga på varje mönster för att tvinga fram skiftlägeskänslighet:

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

Resultat:

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

Och här använder den (?i) flagga för att tvinga fram skiftlägeskänslighet:

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

Resultat:

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

Binära strängar

Skickar en BINARY sträng påverkar också skiftlägeskänsligheten. Med BINARY strängar, skiljer sig ett versaltecken från dess motsvarighet till gemener:

Exempel:

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

Resultat:

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

Så här händer om vi ändrar fallet:

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

Resultat:

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

Skiftlägeskänslighet på BINARY Strängar kan också åsidosättas med (?-i) och (?i) PCRE-flaggor:

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

Resultat:

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

Nollargument

Skickar null eftersom alla argument resulterar i 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";

Resultat:

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

Fel antal argument

Om du skickar fel antal argument eller inga argument, resulterar det i ett fel:

SELECT REGEXP_REPLACE();

Resultat:

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