Jak REGEXP_REPLACE() działa w MariaDB

W MariaDB funkcja REGEXP_REPLACE() funkcja zastępuje wystąpienia podciągu w ciągu, który pasuje do podanego wzorca wyrażenia regularnego.

Zwracany jest cały ciąg wraz z zamiennikami.

Jeśli nie ma dopasowania (tj. ciąg wejściowy nie zawiera podciągu), cały ciąg jest zwracany bez zmian.

Składnia

Składnia wygląda tak:

REGEXP_REPLACE(subject, pattern, replace)

Gdzie subject jest ciągiem wejściowym, pattern jest wzorcem wyrażenia regularnego dla podciągu i replace jest ciągiem zastępczym.

Zwróć uwagę, że w chwili pisania tego tekstu wersja MariaDB funkcji REGEXP_REPLACE() akceptuje mniej argumentów niż REGEXP_REPLACE() MySQL funkcjonować. Wersja MySQL umożliwia podanie argumentów dla pozycji początkowej wyszukiwania, którego wystąpienia należy szukać, a także sposób uściślenia wyrażenia regularnego za pomocą typu dopasowania.

Przykład

Oto podstawowy przykład użycia REGEXP_REPLACE() w MariaDB:

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

Wynik:

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

W tym przypadku występuje dopasowanie, a podciąg jest zastępowany ciągiem zastępczym.

Wyrażenia regularne mogą mieć bardzo duże możliwości, a w tym przykładzie użyto bardzo prostego przykładu. Aby użyć REGEXP_REPLACE() skutecznie, będziesz musiał znać właściwy wzór, aby uzyskać pożądany efekt.

Wiele meczów

Oto przykład z wieloma dopasowaniami:

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

Wynik:

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

Brak dopasowania

Oto przykład, w którym nie ma dopasowania:

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

Wynik:

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

Brak dopasowania, więc oryginalny ciąg jest zwracany bez zmian.

Wrażliwość na wielkość liter

REGEXP_REPLACE() Funkcja jest zgodna z regułami rozróżniania wielkości liter efektywnego sortowania. Dopasowywanie jest wykonywane bez rozróżniania wielkości liter w przypadku sortowania bez rozróżniania wielkości liter oraz z rozróżnianiem wielkości liter w przypadku sortowania z rozróżnianiem wielkości liter i danych binarnych.

Oto przykład:

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

Wynik:

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

Moje domyślne sortowanie nie uwzględnia wielkości liter. Pozostałe dwa ciągi zostały zmuszone do sortowania bez rozróżniania wielkości liter i sortowania z rozróżnianiem wielkości liter.

Zapewnienie BINARY string uwzględnia również wielkość liter (więcej o tym później).

Zastąp czułość wielkości liter

Wrażliwość na wielkość liter w sortowaniu można zmienić za pomocą (?i ) i (?-i ) Flagi PCRE.

Oto poprzedni przykład, ale tym razem przy użyciu (?-i) flaga na każdym wzorze, aby wymusić rozróżnianie wielkości liter:

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

Wynik:

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

A tutaj używa (?i) flaga, aby wymusić niewrażliwość na wielkość liter:

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

Wynik:

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

Ciągi binarne

Przekazywanie BINARY string wpływa również na rozróżnianie wielkości liter. Z BINARY ciągi znaków, znak z dużej litery jest inny niż jego odpowiednik z małej litery:

Przykład:

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

Wynik:

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

Oto, co się stanie, jeśli zmienimy przypadek:

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

Wynik:

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

Rozróżnianie wielkości liter w BINARY ciągi można również nadpisać za pomocą (?-i) i (?i) Flagi PCRE:

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

Wynik:

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

Argumenty zerowe

Przekazywanie null ponieważ dowolny argument daje wynik 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";

Wynik:

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

Niewłaściwa liczba argumentów

Przekazanie nieprawidłowej liczby argumentów lub brak argumentów skutkuje błędem:

SELECT REGEXP_REPLACE();

Wynik:

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