Cómo funciona REGEXP_REPLACE() en MariaDB

En MariaDB, el REGEXP_REPLACE() La función reemplaza las ocurrencias de la subcadena dentro de una cadena que coincide con el patrón de expresión regular dado.

La cadena completa se devuelve junto con los reemplazos.

Si no hay ninguna coincidencia (es decir, la cadena de entrada no contiene la subcadena), la cadena completa se devuelve sin cambios.

Sintaxis

La sintaxis es así:

REGEXP_REPLACE(subject, pattern, replace)

Donde subject es la cadena de entrada, pattern es el patrón de expresión regular para la subcadena y replace es la cadena de reemplazo.

Tenga en cuenta que, en el momento de escribir este artículo, la versión de MariaDB de REGEXP_REPLACE() acepta menos argumentos que REGEXP_REPLACE() de MySQL función. La versión de MySQL le permite proporcionar argumentos para la posición inicial de la búsqueda, qué ocurrencia buscar, así como una forma de refinar la expresión regular con el tipo de coincidencia.

Ejemplo

Aquí hay un ejemplo básico del uso de REGEXP_REPLACE() en MariaDB:

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

Resultado:

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

En este caso, hay una coincidencia y la subcadena se reemplaza con la cadena de reemplazo.

Las expresiones regulares pueden ser muy poderosas, y este ejemplo usa un ejemplo muy simple. Para usar REGEXP_REPLACE() efectivamente, necesitará saber el patrón correcto para usar para el resultado deseado.

Coincidencias Múltiples

Aquí hay un ejemplo con múltiples coincidencias:

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                                |
+----------------------------------------------------------+

Sin coincidencia

Aquí hay un ejemplo donde no hay coincidencia:

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

Resultado:

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

No hay ninguna coincidencia, por lo que la cadena original se devuelve sin cambios.

Sensibilidad de mayúsculas y minúsculas

El REGEXP_REPLACE() La función sigue las reglas de distinción entre mayúsculas y minúsculas de la intercalación efectiva. La coincidencia se realiza sin distinción entre mayúsculas y minúsculas para intercalaciones que no distinguen entre mayúsculas y minúsculas, y entre mayúsculas y minúsculas para intercalaciones que distinguen entre mayúsculas y minúsculas y para datos binarios.

He aquí un ejemplo:

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        |
+------------+------------------+----------------+

Mi intercalación predeterminada no distingue entre mayúsculas y minúsculas. Las otras dos cadenas se forzaron a una intercalación que no distingue entre mayúsculas y minúsculas y una intercalación que distingue entre mayúsculas y minúsculas, respectivamente.

Proporcionar un BINARY la cadena también distingue entre mayúsculas y minúsculas (más sobre esto más adelante).

Anular sensibilidad de mayúsculas y minúsculas

La distinción entre mayúsculas y minúsculas se puede anular mediante (?i ) y (?-i ) Indicadores PCRE.

Aquí está el ejemplo anterior, pero esta vez usando el (?-i) marca en cada patrón para forzar la distinción entre mayúsculas y 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        |
+------------+------------------+----------------+

Y aquí está usando el (?i) marcar para forzar la insensibilidad a mayúsculas y 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        |
+------------+------------------+----------------+

Cadenas binarias

Pasando un BINARY string también afecta la distinción entre mayúsculas y minúsculas. Con BINARY cadenas, un carácter en mayúscula es diferente a su equivalente en minúscula:

Ejemplo:

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 |
+-----------+---------+

Esto es lo que sucede si cambiamos el 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 |
+-----------+---------+

Sensibilidad a mayúsculas y minúsculas en BINARY las cadenas también se pueden anular con (?-i) y (?i) Indicadores PCRE:

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

Pasando null ya que cualquier argumento da como resultado 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 incorrecto de argumentos

Pasar el número incorrecto de argumentos o ningún argumento da como resultado un error:

SELECT REGEXP_REPLACE();

Resultado:

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