En MySQL, 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 NULL .
Sintaxis
La sintaxis es así:
REGEXP_SUBSTR(expr, pat[, pos[, occurrence[, match_type]]])
Donde expr es la cadena de entrada y pat es el patrón de expresión regular para la subcadena.
El pos opcional El argumento le permite especificar una posición dentro de la cadena para iniciar la búsqueda. Si se omite, comienza en la posición 1.
La occurrence opcional El argumento le permite especificar qué ocurrencia de la coincidencia buscar. Si se omite, se utiliza la primera ocurrencia (ocurrencia 1).
El match_type opcional El argumento le permite refinar la expresión regular. Por ejemplo, puede usar este argumento para especificar si distingue entre mayúsculas y minúsculas o no.
Ejemplo 1:uso básico
He aquí un ejemplo básico:
SELECT REGEXP_SUBSTR('Thailand or Cambodia', 'l.nd') Result; Resultado:
+--------+ | Result | +--------+ | land | +--------+
En este caso, hay una coincidencia y se devuelve la subcadena.
Ejemplo 2:coincidencias múltiples
De forma predeterminada, si hay varias coincidencias dentro de la cadena, se devuelve la primera (aunque puede especificar otra ocurrencia si es necesario. Llegaremos a eso pronto):
SELECT REGEXP_SUBSTR('Lend for land', 'l.nd') Result; Resultado:
+--------+ | Result | +--------+ | Lend | +--------+
Ejemplo 3:Sin coincidencia
Aquí hay un ejemplo donde no hay coincidencia:
SELECT REGEXP_SUBSTR('Lend for land', '^C') Result; Resultado:
+--------+ | Result | +--------+ | NULL | +--------+
No hay coincidencia, por lo que el resultado es NULL .
Ejemplo 4:el pos Argumento
Este es un ejemplo de cómo especificar una posición inicial:
SELECT REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2) Result; Resultado:
+--------+ | Result | +--------+ | Cut | +--------+
Comenzamos en la posición 2, que viene después del inicio de la primera aparición, por lo que en su lugar se devuelve la siguiente aparición.
Aquí hay otro ejemplo:
SELECT
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1) 'Pos 1',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2) 'Pos 2',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 6) 'Pos 6'; Resultado:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | Cat | Cut | Cot | +-------+-------+-------+
Ejemplo 5:la occurrence Argumento
Aquí hay un ejemplo del uso de la occurrence argumento. En todos los casos, comenzamos en la posición 1:
SELECT
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 1) 'Occurrence 1',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 2) 'Occurrence 2',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 1, 3) 'Occurrence 3'; Resultado:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | Cat | Cut | Cot | +--------------+--------------+--------------+
Sin embargo, si comenzamos en una posición diferente, el resultado es diferente:
SELECT
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 1) 'Occurrence 1',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 2) 'Occurrence 2',
REGEXP_SUBSTR('Cat Cut Cot', 'C.t', 2, 3) 'Occurrence 3'; Resultado:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | Cut | Cot | NULL | +--------------+--------------+--------------+
Esto sucedió porque nuestra posición inicial se produjo después de que comenzara la primera ocurrencia. Por lo tanto, la ocurrencia 2 se convirtió en la ocurrencia 1 y la ocurrencia 3 se convirtió en la ocurrencia 2. Y debido a que no hubo más ocurrencias, el resultado de la ocurrencia 3 fue NULL (es decir, no hubo ocurrencia 3).
Ejemplo 6:el match_type Argumento
Puede proporcionar un argumento adicional para determinar el tipo de coincidencia. Esto le permite especificar cosas como si la coincidencia distingue entre mayúsculas y minúsculas o no, si debe incluir o no terminadores de línea, etc.
Este es un ejemplo de cómo especificar una coincidencia que distingue entre mayúsculas y minúsculas y una coincidencia que no distingue entre mayúsculas y minúsculas:
SELECT
REGEXP_SUBSTR('Cat Cut Cot', 'c.t', 1, 1, 'c') 'Case-Sensitive',
REGEXP_SUBSTR('Cat Cut Cot', 'c.t', 1, 1, 'i') 'Case-Insensitive'; Resultado:
+----------------+------------------+ | Case-Sensitive | Case-Insensitive | +----------------+------------------+ | NULL | Cat | +----------------+------------------+
El match_type argumento puede contener los siguientes caracteres:
c- Coincidencia sensible a mayúsculas y minúsculas.
i- Coincidencia insensible a mayúsculas y minúsculas.
m- Modo de varias líneas. Reconocer los terminadores de línea dentro de la cadena. El comportamiento predeterminado es hacer coincidir los terminadores de línea solo al principio y al final de la expresión de cadena.
n- El
.el carácter coincide con los terminadores de línea. El valor predeterminado es para.coincidencia para detenerse al final de una línea. u- Finales de línea exclusivos de Unix. Solo el carácter de nueva línea se reconoce como una línea que termina con
.,^y$operadores de coincidencia.
