Como REGEXP_REPLACE() funciona no MariaDB

No MariaDB, o REGEXP_REPLACE() A função substitui as ocorrências da substring dentro de uma string que corresponde ao padrão de expressão regular fornecido.

A string inteira é retornada junto com as substituições.

Se não houver correspondência (ou seja, a string de entrada não contém a substring), a string inteira é retornada inalterada.

Sintaxe

A sintaxe fica assim:

REGEXP_REPLACE(subject, pattern, replace)

Onde subject é a string de entrada, pattern é o padrão de expressão regular para a substring e replace é a cadeia de substituição.

Observe que, no momento da escrita, a versão do MariaDB de REGEXP_REPLACE() aceita menos argumentos que o REGEXP_REPLACE() do MySQL função. A versão do MySQL permite fornecer argumentos para a posição inicial da pesquisa, qual ocorrência procurar, bem como uma forma de refinar a expressão regular com o tipo de correspondência.

Exemplo

Aqui está um exemplo básico de uso de REGEXP_REPLACE() em MariaDB:

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

Resultado:

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

Nesse caso, há uma correspondência e a substring é substituída pela string de substituição.

Expressões regulares podem ser muito poderosas, e este exemplo usa um exemplo muito simples. Para usar REGEXP_REPLACE() efetivamente, você precisará saber o padrão correto a ser usado para o resultado desejado.

Várias correspondências

Aqui está um exemplo com várias correspondências:

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

Resultado:

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

Sem correspondência

Aqui está um exemplo em que não há correspondência:

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

Resultado:

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

Não há correspondência, então a string original é retornada inalterada.

Sensibilidade de maiúsculas e minúsculas

O REGEXP_REPLACE() A função segue as regras de diferenciação de maiúsculas e minúsculas da ordenação efetiva. A correspondência é realizada sem distinção entre maiúsculas e minúsculas para ordenações que não diferenciam maiúsculas de minúsculas e com distinção entre maiúsculas e minúsculas para ordenações que diferenciam maiúsculas de minúsculas e para dados binários.

Aqui está um exemplo:

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

Resultado:

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

Meu agrupamento padrão não diferencia maiúsculas de minúsculas. As outras duas strings foram forçadas a uma ordenação sem distinção entre maiúsculas e minúsculas e ordenação com distinção entre maiúsculas e minúsculas, respectivamente.

Fornecendo um BINARY string também diferencia maiúsculas de minúsculas (mais sobre isso posteriormente).

Substituir distinção entre maiúsculas e minúsculas

A distinção entre maiúsculas e minúsculas do agrupamento pode ser substituída usando o (?i ) e (?-i ) sinalizadores PCRE.

Aqui está o exemplo anterior, mas desta vez usando o (?-i) sinalizar em cada padrão para forçar a diferenciação entre maiúsculas e minúsculas:

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

Resultado:

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

E aqui está usando o (?i) sinalizador para forçar a diferenciação entre maiúsculas e minúsculas:

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

Resultado:

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

Strings binárias

Passando um BINARY string também afeta a distinção entre maiúsculas e minúsculas. Com BINARY strings, um caractere maiúsculo é diferente de sua contraparte minúscula:

Exemplo:

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

Resultado:

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

Aqui está o que acontece se mudarmos o caso:

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

Resultado:

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

Diferenciação de maiúsculas e minúsculas em BINARY strings também podem ser substituídas pelo (?-i) e (?i) Sinalizadores de PCR:

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

Resultado:

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

Argumentos nulos

Passando null pois qualquer argumento resulta em 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";

Resultado:

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

Número errado de argumentos

Passar o número errado de argumentos ou nenhum argumento resulta em um erro:

SELECT REGEXP_REPLACE();

Resultado:

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