En MySQL, REGEXP_INSTR() La función devuelve el índice inicial de una subcadena que coincide con el patrón de expresión regular.
El índice comienza en 1 . Si no hay ninguna coincidencia, el resultado es 0 .
Sintaxis
La sintaxis es así:
REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, 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).
La return_option opcional El argumento le permite especificar qué tipo de posición devolver. Si usa 0 , devolverá la posición del primer carácter en la subcadena coincidente. Si usa 1 devuelve la posición del primer carácter siguiente la subcadena coincidente. Si se omite, el valor es 0 .
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_INSTR('Cat', 'at') Result; Resultado:
+--------+ | Result | +--------+ | 2 | +--------+
En este caso, hay una coincidencia y la subcadena comienza en la posición 2.
Ejemplo 2:Sin coincidencia
Aquí hay un ejemplo donde no hay coincidencia:
SELECT REGEXP_INSTR('Cat', '^at') Result; Resultado:
+--------+ | Result | +--------+ | 0 | +--------+
No hay ninguna coincidencia, por lo que el resultado es 0 . No hay coincidencia porque especifiqué que la cadena debe comenzar con la subcadena.
Vamos a cambiarlo para que lo haga comienza con esa subcadena:
SELECT REGEXP_INSTR('at', '^at') Result; Resultado:
+--------+ | Result | +--------+ | 1 | +--------+
Ejemplo 3:el pos Argumento
Este es un ejemplo de cómo especificar una posición inicial:
SELECT REGEXP_INSTR('Cat Cat', 'Cat', 2) Result; Resultado:
+--------+ | Result | +--------+ | 5 | +--------+
Entonces obtenemos el índice de la segunda ocurrencia.
Tenga en cuenta que el índice aún comienza a contar desde la posición 1, independientemente de dónde especifique la posición inicial.
El siguiente ejemplo demuestra esto más claramente:
SELECT
REGEXP_INSTR('Cat Cat', 'Cat', 2) AS 'Pos 2',
REGEXP_INSTR('Cat Cat', 'Cat', 3) AS 'Pos 3',
REGEXP_INSTR('Cat Cat', 'Cat', 5) AS 'Pos 5'; Resultado:
+-------+-------+-------+ | Pos 2 | Pos 3 | Pos 5 | +-------+-------+-------+ | 5 | 5 | 5 | +-------+-------+-------+
Por supuesto, dependiendo de su patrón de expresiones regulares, esto puede devolver el índice de subcadenas completamente diferentes. Ejemplo:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1) 'Pos 1',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2) 'Pos 2',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 6) 'Pos 6'; Resultado:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | 1 | 5 | 16 | +-------+-------+-------+
Podemos verificar las subcadenas con REGEXP_SUBSTR() función:
SELECT
REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 1) 'Pos 1',
REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 2) 'Pos 2',
REGEXP_SUBSTR('Cat City is SO Cute!', 'C.t', 6) 'Pos 6'; Resultado:
+-------+-------+-------+ | Pos 1 | Pos 2 | Pos 6 | +-------+-------+-------+ | Cat | Cit | Cut | +-------+-------+-------+
Ejemplo 4: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_INSTR('Cat City is SO Cute!', 'C.t', 1, 1) 'Occurrence 1',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2) 'Occurrence 2',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3) 'Occurrence 3'; Resultado:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 1 | 5 | 16 | +--------------+--------------+--------------+
Sin embargo, si comenzamos en una posición diferente, el resultado es diferente:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 1) 'Occurrence 1',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 2) 'Occurrence 2',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 2, 3) 'Occurrence 3'; Resultado:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 5 | 16 | 0 | +--------------+--------------+--------------+
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 negativo (es decir, no hubo ocurrencia 3).
Ejemplo 5:la return_option Argumento
Aquí hay un ejemplo del uso de return_option argumento:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 0) 'Option 0',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 1) 'Option 1';
Resultado:
+----------+----------+ | Option 0 | Option 1 | +----------+----------+ | 1 | 4 | +----------+----------+
La opción 0 devolvió el primer carácter de la subcadena coincidente. La opción 1 devolvió la posición que sigue a la subcadena coincidente.
Así es como se ve si lo aplicamos al ejemplo anterior:
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 0) 'Occurrence 1',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2, 0) 'Occurrence 2',
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3, 0) 'Occurrence 3'
UNION ALL
SELECT
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 1),
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 2, 1),
REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 3, 1);
Resultado:
+--------------+--------------+--------------+ | Occurrence 1 | Occurrence 2 | Occurrence 3 | +--------------+--------------+--------------+ | 1 | 5 | 16 | | 4 | 8 | 19 | +--------------+--------------+--------------+
En este caso, hicimos un conjunto usando la opción 0 y otro usando la opción 1, luego los unimos usando UNION ALL .
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_INSTR('Cat City is SO Cute!', 'c.t', 1, 1, 0, 'c') 'Case-Sensitive',
REGEXP_INSTR('Cat City is SO Cute!', 'c.t', 1, 1, 0, 'i') 'Case-Insensitive'; Resultado:
+----------------+------------------+ | Case-Sensitive | Case-Insensitive | +----------------+------------------+ | 0 | 1 | +----------------+------------------+
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.
