sql >> Base de Datos >  >> RDS >> Oracle

Función REGEXP_REPLACE() en Oracle

En Oracle, REGEXP_REPLACE() La función reemplaza las ocurrencias de la subcadena dentro de una cadena que coincide con el patrón de expresión regular dado.

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

Sintaxis

La sintaxis es así:

REGEXP_REPLACE ( source_char, pattern
                 [, replace_string
                    [, position
                       [, occurrence
                          [, match_param ]
                       ]
                    ]
                 ]
               )

donde:

  • source_char es una expresión de carácter que sirve como valor de búsqueda.
  • pattern es la expresión regular.
  • replace_string es la cadena de reemplazo.
  • 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 reemplazar. El valor predeterminado es 0 , lo que significa reemplazar todas las apariciones.
  • 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 obtener más información.

Ejemplo

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

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

Resultado:

Cats and birds

En este caso, hay una coincidencia y la subcadena se reemplaza con la cadena de reemplazo.

Las expresiones regulares pueden ser muy poderosas, y este ejemplo usa un ejemplo muy simple. Para usar REGEXP_REPLACE() 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_REPLACE('Cats and dogs', 't.g', 'bird');

Resultado:

+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 't.g', 'bird') |
+------------------------------------------------+
| Cats and dogs                                  |
+------------------------------------------------+

No hay ninguna coincidencia, por lo que la cadena original se devuelve sin cambios.

Coincidencias Múltiples

Este es un ejemplo con múltiples coincidencias:

SELECT 
    REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird')
FROM DUAL;

Resultado:

My bird likes other birds

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

SELECT 
REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird', 1, 2)
FROM DUAL;

Resultado:

My dog likes other birds

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 reemplazar. En este caso, se reemplaza la segunda ocurrencia.

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

SELECT 
REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird', 7, 2)
FROM DUAL;

Resultado:

My dog likes other dogs

En este caso, la cadena no se actualiza porque solo hay una ocurrencia más después de la posición inicial.

Si cambio el último argumento a 1 , luego se actualiza como se especifica (porque es la primera aparición después de la posición de inicio especificada):

SELECT 
REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird', 7, 1)
FROM DUAL;

Resultado:

My dog likes other birds

Y en caso de que te lo estés preguntando, 0 especifica todas las ocurrencias:

SELECT REGEXP_REPLACE(
    'My dog likes big dogs and small dogs', 
    'd.g', 
    'bird', 1, 0
    )
FROM DUAL;

Resultado:

My bird likes big birds and small birds

Pero aún respeta cualquier posición inicial que se haya especificado:

SELECT REGEXP_REPLACE(
    'My dog likes big dogs and small dogs', 
    'd.g', 
    'bird', 7, 0
    )
FROM DUAL;

Resultado:

My dog likes big birds and small birds

Sensibilidad de mayúsculas y minúsculas

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

Resultado:

   Default    Case Insensitive    Case Sensitive 
__________ ___________________ _________________ 
My Cats    My dogs             My Cats

A partir de estos resultados, parece que mi intercalación predeterminada distingue entre mayúsculas y minúsculas. Las otras dos cadenas fueron forzadas a una coincidencia entre mayúsculas y minúsculas y mayúsculas y minúsculas, respectivamente.

Argumentos nulos

Pasando null da como resultado null para la mayoría de los argumentos, excepto para el segundo y el sexto argumento:

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

Resultado:

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

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_REPLACE()
FROM DUAL;

Resultado:

Error starting at line : 1 in command -
SELECT REGEXP_REPLACE()
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 con pasar demasiados argumentos:

SELECT REGEXP_REPLACE('Cat', 'c.t', 'dog', 1, 0, 'i', 'oops')
FROM DUAL;

Resultado:

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