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 es1
, 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 es1
, 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 conREGEXP_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 enpattern
debe ser devuelto por la función. Este argumento funciona igual que cuando se usa conREGEXP_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.