Cómo funciona REGEXP_SUBSTR() en MariaDB

En MariaDB, el REGEXP_SUBSTR() La función devuelve la subcadena que coincide con el patrón de expresión regular dado.

Si no hay ninguna coincidencia (es decir, la cadena de entrada no contiene la subcadena), el resultado es una cadena vacía.

Sintaxis

La sintaxis es así:

REGEXP_SUBSTR(subject,pattern)

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

Tenga en cuenta que, en el momento de escribir este artículo, la versión de MariaDB de REGEXP_SUBSTR() acepta menos argumentos que REGEXP_SUBSTR() de MySQL . 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.

Ejemplo

He aquí un ejemplo básico:

SELECT REGEXP_SUBSTR('Thailand and Laos', 'l.nd');

Resultado:

+--------------------------------------------+
| REGEXP_SUBSTR('Thailand and Laos', 'l.nd') |
+--------------------------------------------+
| land                                       |
+--------------------------------------------+

En este caso, hay una coincidencia y se devuelve la subcadena.

Coincidencias Múltiples

De forma predeterminada, si hay varias coincidencias dentro de la cadena, se devuelve la primera:

SELECT REGEXP_SUBSTR('Lend for land', 'l.nd');

Resultado:

+----------------------------------------+
| REGEXP_SUBSTR('Lend for land', 'l.nd') |
+----------------------------------------+
| Lend                                   |
+----------------------------------------+

Sin coincidencia

Aquí hay un ejemplo donde no hay coincidencia:

SELECT REGEXP_SUBSTR('Lend for land', '^C');

Resultado:

+--------------------------------------+
| REGEXP_SUBSTR('Lend for land', '^C') |
+--------------------------------------+
|                                      |
+--------------------------------------+

No hay ninguna coincidencia, por lo que el resultado es una cadena vacía.

Sensibilidad de mayúsculas y minúsculas

El REGEXP_SUBSTR() 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_SUBSTR('My Cats', 'c.t') AS "My Default",
    REGEXP_SUBSTR(_latin7'My Cats' COLLATE latin7_general_ci, 'c.t') AS "Case Insensitive",
    REGEXP_SUBSTR(_latin7'My Cats' COLLATE latin7_general_cs, 'c.t') AS "Case Sensitive";

Resultado:

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

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 (ver más abajo).

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_SUBSTR('My Cats', 'c.t') AS "Character",
    REGEXP_SUBSTR(BINARY 'My Cats', 'c.t') AS "Binary";

Resultado:

+-----------+--------+
| Character | Binary |
+-----------+--------+
| Cat       |        |
+-----------+--------+

Esto es lo que sucede si cambiamos el caso:

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

Resultado:

+-----------+--------+
| Character | Binary |
+-----------+--------+
| Cat       | Cat    |
+-----------+--------+

Argumentos nulos

Pasando null ya que cualquier argumento da como resultado null :

SELECT 
    REGEXP_SUBSTR(null, 'c.t') AS "1",
    REGEXP_SUBSTR('Cat', null) AS "2",
    REGEXP_SUBSTR(null, null) AS "3";

Resultado:

+------+------+------+
| 1    | 2    | 3    |
+------+------+------+
| 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_SUBSTR('Cat');

Resultado:

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