Función REGEXP_SUBSTR() en Oracle

En Oracle, REGEXP_SUBSTR() La función devuelve una subcadena de una cadena, según un patrón de expresión regular.

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

Sintaxis

La sintaxis es así:

REGEXP_SUBSTR ( source_char, pattern
                [, position
                   [, occurrence
                      [, 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 no negativo que especifica qué ocurrencia buscar. El valor predeterminado es 1 , lo que significa que busca la primera aparición.
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_SUBSTR() en Oráculo:

SELECT 
    REGEXP_SUBSTR('Cats and dogs', 'd.g')
FROM DUAL;

Resultado:

dog

En este caso, hay una coincidencia y se devuelve la primera (y en este caso, la única) subcadena coincidente.

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

Sin coincidencia

Aquí hay un ejemplo donde no hay coincidencia:

SET NULL 'null';
SELECT REGEXP_SUBSTR('My dogs like dregs', 't.g')
FROM DUAL;

Resultado:

null

No hay ninguna coincidencia, por lo que null es devuelto.

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.

Coincidencias Múltiples

Aquí hay un ejemplo con múltiples coincidencias:

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

Resultado:

dog

Sin embargo, puede especificar qué ocurrencia reemplazar si es necesario:

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

Resultado:

dag

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_SUBSTR('My dogs have dags', 'd.g', 8, 2)
FROM DUAL;

Resultado:

null

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_SUBSTR('My dogs have dags', 'd.g', 8, 1)
FROM DUAL;

Resultado:

dag

Sensibilidad de mayúsculas y minúsculas

El REGEXP_SUBSTR() 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 quinto 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_SUBSTR('My Cats', 'c.t', 1, 1) AS "Default",
    REGEXP_SUBSTR('My Cats', 'c.t', 1, 1, 'i') AS "Case Insensitive",
    REGEXP_SUBSTR('My Cats', 'c.t', 1, 1, 'c') AS "Case Sensitive"
FROM DUAL;

Resultado:

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
null       Cat                 null

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_SUBSTR(
    'catdogcow', 
    '(c.t)(d.g)(c.w)', 
    1, 1, 'i', 1
    )
FROM DUAL;

Resultado:

cat

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

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

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

Resultado:

cow

Argumentos nulos

Si algún argumento es null , el resultado es null :

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

Resultado:

      1       2       3       4       5       6 
_______ _______ _______ _______ _______ _______ 
null    null    null    null    null    null

Número incorrecto de argumentos

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

SELECT REGEXP_SUBSTR()
FROM DUAL;

Resultado:

Error starting at line : 1 in command -
SELECT REGEXP_SUBSTR()
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_SUBSTR('Cat', 'c.t', 1, 1, 'i', 1, 'oops')
FROM DUAL;

Resultado:

Error starting at line : 1 in command -
SELECT REGEXP_SUBSTR('Cat', 'c.t', 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_SUBSTR() (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_SUBSTR() función.