Función REGEXP_INSTR() en Oracle

En Oracle, REGEXP_INSTR() función busca una cadena para un patrón de expresión regular. Devuelve un número entero que indica la posición inicial o final de la subcadena coincidente (cualquiera que especifique).

Extiende la funcionalidad del INSTR() función permitiéndonos usar patrones de expresiones regulares.

Sintaxis

La sintaxis es así:

REGEXP_INSTR ( source_char, pattern
               [, position
                  [, occurrence
                     [, return_opt
                        [, match_param
                           [, subexpr ]
                        ]
                     ]
                  ]
               ]
             )

donde:

source_char es una expresión de carácter que sirve como valor de búsqueda.
pattern es la expresión regular.
position es un entero positivo que especifica dónde comenzar la búsqueda. El valor predeterminado es 1 , es decir, comience la búsqueda en el primer carácter.
occurrence es un entero positivo que especifica qué ocurrencia buscar. El valor predeterminado es 1 , lo que significa que busca la primera aparición.
return_opt especifica si Oracle debe devolver la posición inicial o final de la subcadena coincidente. Usa 0 para el principio, y 1 para el final El valor predeterminado es 0 .
match_param le permite cambiar el comportamiento de coincidencia predeterminado de la función. Por ejemplo, le permite especificar la distinción entre mayúsculas y minúsculas, cómo se tratan varias líneas y espacios, etc. Este argumento funciona igual que cuando se usa con REGEXP_COUNT() función. Consulte la documentación de Oracle para esa función para obtener más información.
Para un pattern con subexpresiones, subexpr es un entero no negativo de 0 a 9 que indica qué subexpresión en pattern debe ser devuelto por la función. Este argumento funciona igual que cuando se usa con REGEXP_INSTR() función. Consulte la documentación de Oracle para obtener más información sobre esa función.

Ejemplo

Aquí hay un ejemplo básico del uso de REGEXP_INSTR() en Oráculo:

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g')
FROM DUAL;

Resultado:

En este caso, hay una coincidencia y se devuelve la posición inicial de la subcadena.

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

Sin coincidencia

Aquí hay un ejemplo donde no hay coincidencia:

SELECT REGEXP_INSTR('My dogs like dregs', 't.g')
FROM DUAL;

Resultado:

No hay coincidencia, entonces 0 es devuelto.

Coincidencias Múltiples

Aquí hay un ejemplo con múltiples coincidencias:

SELECT 
    REGEXP_INSTR('My dogs have dags', 'd.g')
FROM DUAL;

Resultado:

Devolvió la posición de la primera aparición.

Sin embargo, puede especificar qué ocurrencia reemplazar:

SELECT 
REGEXP_INSTR('My dogs have dags', 'd.g', 1, 2)
FROM DUAL;

Resultado:

Tenga en cuenta que agregué dos argumentos aquí; 1 y 2 . El 1 especifica el paradero en la cadena para iniciar la búsqueda (en este caso, en el primer carácter). El 2 es lo que especifica qué ocurrencia buscar. En este caso, se busca la segunda ocurrencia.

Esto es lo que sucede si empiezo la búsqueda después de la primera aparición:

SELECT 
REGEXP_INSTR('My dogs have dags', 'd.g', 8, 2)
FROM DUAL;

Resultado:

En este caso no hay coincidencia, porque solo hay una aparición más después de la posición inicial.

Si cambio el último argumento a 1 , luego obtenemos una coincidencia (porque es la primera aparición después de la posición de inicio especificada):

SELECT 
REGEXP_INSTR('My dogs have dags', 'd.g', 8, 1)
FROM DUAL;

Resultado:

Regresar a la posición final

Puede pasar un quinto argumento de cualquiera de 0 o 1 para especificar si la función debe devolver la posición inicial o final de la subcadena.

El valor predeterminado es 0 (para la posición inicial). Esto es lo que sucede si especificamos 1 :

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 1)
FROM DUAL;

Resultado:

Para que quede claro, aquí está de nuevo en comparación con 0 :

SELECT 
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 0) AS "Start",
    REGEXP_INSTR('My dogs are fluffy', 'd.g', 1, 1, 1) AS "End"
FROM DUAL;

Resultado:

   Start    End 
________ ______ 
       4      7

Sensibilidad de mayúsculas y minúsculas

El REGEXP_INSTR() La función sigue las reglas de derivación y determinación de intercalación de Oracle, que definen la intercalación que se utilizará al hacer coincidir la cadena con el patrón.

Sin embargo, puede especificar explícitamente la distinción entre mayúsculas y minúsculas con el sexto argumento opcional. Cuando hace esto, anula cualquier distinción entre mayúsculas y minúsculas o acentos de la intercalación determinada.

Puede especificar i para coincidencias que no distinguen entre mayúsculas y minúsculas y c para hacer coincidir mayúsculas y minúsculas.

He aquí un ejemplo:

SELECT 
    REGEXP_INSTR('My Cats', 'c.t', 1, 1, 0) AS "Default",
    REGEXP_INSTR('My Cats', 'c.t', 1, 1, 0, 'i') AS "Case Insensitive",
    REGEXP_INSTR('My Cats', 'c.t', 1, 1, 0, 'c') AS "Case Sensitive"
FROM DUAL;

Resultado:

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
         0                   4                 0

Mi intercalación parece distinguir entre mayúsculas y minúsculas, según estos resultados. Las otras dos cadenas fueron forzadas a una coincidencia entre mayúsculas y minúsculas y mayúsculas y minúsculas, respectivamente.

Subexpresiones

Este es un ejemplo del uso del sexto argumento para devolver un patrón de subexpresión específico:

SELECT REGEXP_INSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 0, 'i', 1
    )
FROM DUAL;

Resultado:

En este caso, devolví la primera subexpresión.

Esto es lo que sucede si especifico la tercera subexpresión:

SELECT REGEXP_INSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 0, 'i', 3
    )
FROM DUAL;

Resultado:

Argumentos nulos

Con la excepción del sexto argumento, proporcionando null para un argumento da como resultado null :

SET NULL 'null';
SELECT 
    REGEXP_INSTR(null, 'c.t', 1, 1, 0, 'i', 1) AS "1",
    REGEXP_INSTR('Cat', null, 1, 1, 0, 'i', 1) AS "2",
    REGEXP_INSTR('Cat', 'c.t', null, 1, 0, 'i', 1) AS "3",
    REGEXP_INSTR('Cat', 'c.t', 1, null, 0, 'i', 1) AS "4",
    REGEXP_INSTR('Cat', 'c.t', 1, 1, null, 'i', 1) AS "5",
    REGEXP_INSTR('Cat', 'c.t', 1, 1, 0, null, 1) AS "6",
    REGEXP_INSTR('Cat', 'c.t', 1, 1, 0, 'i', null) AS "7"
FROM DUAL;

Resultado:

      1       2       3       4       5    6       7 
_______ _______ _______ _______ _______ ____ _______ 
   null    null    null    null    null    0    null

De forma predeterminada, SQLcl y SQL*Plus devuelven un espacio en blanco cada vez que null ocurre como resultado de un SQL SELECT declaración.

Sin embargo, puede usar SET NULL para especificar una cadena diferente a devolver. Aquí especifiqué que la cadena null debe ser devuelto.

Número incorrecto de argumentos

No pasar argumentos a la función, o pasar muy pocos, da como resultado un error:

SELECT REGEXP_INSTR()
FROM DUAL;

Resultado:

Error starting at line : 1 in command -
SELECT REGEXP_INSTR()
FROM DUAL
Error at Command Line : 1 Column : 8
Error report -
SQL Error: ORA-00938: not enough arguments for function
00938. 00000 -  "not enough arguments for function"
*Cause:    
*Action:

Lo mismo se aplica cuando pasamos demasiados argumentos:

SELECT REGEXP_INSTR('Cat', 'c.t', 1, 1, 1, 'i', 1, 'oops')
FROM DUAL;

Resultado:

Error starting at line : 1 in command -
SELECT REGEXP_INSTR('Cat', 'c.t', 1, 1, 1, 'i', 1, 'oops')
FROM DUAL
Error at Command Line : 1 Column : 8
Error report -
SQL Error: ORA-00939: too many arguments for function
00939. 00000 -  "too many arguments for function"
*Cause:    
*Action:

Más información

El REGEXP_INSTR() (así como otras implementaciones de expresiones regulares de Oracle) se ajusta al estándar de expresiones regulares de la Interfaz de sistema operativo portátil (POSIX) de IEEE y a las Directrices de expresiones regulares de Unicode del Consorcio Unicode.

Consulte la documentación de Oracle para obtener más información y ejemplos de REGEXP_INSTR() función.