V MariaDB, REGEXP_REPLACE() funkce nahradí výskyty podřetězce v řetězci, který odpovídá danému vzoru regulárního výrazu.
Celý řetězec se vrátí spolu s náhradami.
Pokud neexistuje žádná shoda (tj. vstupní řetězec neobsahuje podřetězec), vrátí se celý řetězec beze změny.
Syntaxe
Syntaxe vypadá takto:
REGEXP_REPLACE(subject, pattern, replace)
Kde subject je vstupní řetězec, pattern je vzor regulárního výrazu pro podřetězec a replace je náhradní řetězec.
Všimněte si, že v době psaní tohoto článku byla MariaDB verze REGEXP_REPLACE() přijímá méně argumentů než REGEXP_REPLACE() MySQL funkce. Verze MySQL vám umožňuje poskytnout argumenty pro počáteční pozici vyhledávání, který výskyt hledat, a také způsob, jak upřesnit regulární výraz pomocí typu shody.
Příklad
Zde je základní příklad použití REGEXP_REPLACE() v MariaDB:
SELECT REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird');Výsledek:
+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird') |
+------------------------------------------------+
| Cats and birds |
+------------------------------------------------+ V tomto případě existuje shoda a podřetězec je nahrazen náhradním řetězcem.
Regulární výrazy mohou být velmi výkonné a tento příklad používá velmi jednoduchý příklad. Chcete-li použít REGEXP_REPLACE() efektivně, budete potřebovat znát správný vzor, který použijete pro požadovaný výsledek.
Více shod
Zde je příklad s více shodami:
SELECT REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird');Výsledek:
+----------------------------------------------------------+
| REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird') |
+----------------------------------------------------------+
| My bird likes other birds |
+----------------------------------------------------------+ Žádná shoda
Zde je příklad, kdy neexistuje žádná shoda:
SELECT REGEXP_REPLACE('Cats and dogs', 't.g', 'bird');Výsledek:
+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 't.g', 'bird') |
+------------------------------------------------+
| Cats and dogs |
+------------------------------------------------+ Neexistuje žádná shoda, takže původní řetězec je vrácen beze změny.
Rozlišovat malá a velká písmena
REGEXP_REPLACE() funkce se řídí pravidly rozlišování malých a velkých písmen efektivního řazení. Párování se provádí bez rozlišení malých a velkých písmen u porovnávání bez rozlišení malých a velkých písmen a u porovnávání rozlišujících malá a velká písmena a u binárních dat.
Zde je příklad:
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";Výsledek:
+------------+------------------+----------------+ | My Default | Case Insensitive | Case Sensitive | +------------+------------------+----------------+ | My dogs | My dogs | My Cats | +------------+------------------+----------------+
Moje výchozí řazení nerozlišuje malá a velká písmena. Zbývající dva řetězce byly nuceny používat řazení bez rozlišení malých a velkých písmen, respektive řazení rozlišující malá a velká písmena.
Poskytování BINARY řetězec také rozlišuje velká a malá písmena (více o tom později).
Přepsat rozlišování malých a velkých písmen
Citlivost řazení malých a velkých písmen lze potlačit pomocí (?i ) a (?-i ) Příznaky PCRE.
Zde je předchozí příklad, ale tentokrát s použitím (?-i) příznak na každém vzoru pro vynucení rozlišení velkých a malých písmen:
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";Výsledek:
+------------+------------------+----------------+ | My Default | Case Insensitive | Case Sensitive | +------------+------------------+----------------+ | My Cats | My Cats | My Cats | +------------+------------------+----------------+
A zde je to pomocí (?i) příznak pro vynucení rozlišování malých a velkých písmen:
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";Výsledek:
+------------+------------------+----------------+ | My Default | Case Insensitive | Case Sensitive | +------------+------------------+----------------+ | My dogs | My dogs | My dogs | +------------+------------------+----------------+
Binární řetězce
Předávání BINARY řetězec také ovlivňuje citlivost. S BINARY řetězce, velký znak se liší od malého protějšku:
Příklad:
SELECT
REGEXP_REPLACE('My Cats', 'c.t', 'dog') AS "Character",
REGEXP_REPLACE(BINARY 'My Cats', 'c.t', 'dog') AS "Binary";Výsledek:
+-----------+---------+ | Character | Binary | +-----------+---------+ | My dogs | My Cats | +-----------+---------+
Pokud změníme velikost písmen, stane se toto:
SELECT
REGEXP_REPLACE('My Cats', 'C.t', 'dog') AS "Character",
REGEXP_REPLACE(BINARY 'My Cats', 'C.t', 'dog') AS "Binary";Výsledek:
+-----------+---------+ | Character | Binary | +-----------+---------+ | My dogs | My dogs | +-----------+---------+
Rozlišování malých a velkých písmen na BINARY řetězce lze také přepsat pomocí (?-i) a (?i) Příznaky PCRE:
SELECT
REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "Character",
REGEXP_REPLACE(BINARY 'My Cats', '(?-i)c.t', 'dog') AS "Binary";Výsledek:
+-----------+---------+ | Character | Binary | +-----------+---------+ | My Cats | My Cats | +-----------+---------+
Nulové argumenty
Předávání null protože jakýkoli argument má za následek 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";Výsledek:
+------+------+------+------+ | 1 | 2 | 3 | 4 | +------+------+------+------+ | NULL | NULL | NULL | NULL | +------+------+------+------+
Špatný počet argumentů
Předání nesprávného počtu argumentů nebo žádné argumenty vede k chybě:
SELECT REGEXP_REPLACE();Výsledek:
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'REGEXP_REPLACE'