Función INSTR() en Oracle

En Oracle, el INSTR() La función busca una subcadena en una cadena determinada y devuelve un número entero que indica la posición del primer carácter de esta subcadena. Si no se encuentra la subcadena, la función devuelve 0 .

INSTR() requiere al menos dos argumentos; la cadena y la subcadena. También acepta un tercer y cuarto argumento opcionales que le permiten especificar la posición inicial para buscar y qué ocurrencia buscar.

INSTR() también se puede considerar como un grupo de funciones. Hay cinco funciones separadas; INSTR() , INSTRB() , INSTRC() , INSTR2() y INSTR4() . Cada función calcula la longitud de forma diferente.

Sintaxis

La sintaxis es así:

{ INSTR
| INSTRB
| INSTRC
| INSTR2
| INSTR4
}
(string , substring [, position [, occurrence ] ])

Donde string es la cadena a buscar, substring es la subcadena a buscar, position es la posición inicial de la subcadena y occurrence es qué ocurrencia encontrar.

Las funciones calculan las longitudes de la siguiente manera:

Ejemplo

He aquí un ejemplo básico:

SELECT INSTR('Big fat cat', 'fat')
FROM DUAL;

Resultado:

5

Comparado con INSTRB()

Este ejemplo muestra cómo los resultados pueden diferir, según la función específica que esté utilizando y el juego de caracteres involucrado.

En este caso, comparamos INSTR() con INSTRB() :

SELECT 
    INSTR('Böyük yağlı pişik', 'yağlı') AS INSTR,
    INSTRB('Böyük yağlı pişik', 'yağlı') AS INSTRB
FROM DUAL;

Resultado:

   INSTR    INSTRB 
________ _________ 
       7         9

Podemos ver que las dos funciones arrojaron dos resultados diferentes. Esto se debe a que algunos caracteres de esta cadena utilizan dos bytes.

El INSTR() devuelve la posición definida por el conjunto de caracteres de entrada, mientras que INSTRB() la función devuelve la posición basada en bytes .

Si volvemos a la cadena original, los resultados son los mismos entre las dos funciones:

SELECT 
    INSTR('Big fat cat', 'fat') AS INSTR,
    INSTRB('Big fat cat', 'fat') AS INSTRB
FROM DUAL;

Resultado:

   INSTR    INSTRB 
________ _________ 
       5         5 

Esto se debe a que esta cadena usa solo un byte por carácter, por lo que la longitud en bytes es la misma que la cantidad de caracteres.

Posición inicial

Aquí hay un ejemplo que especifica la posición por la cual comenzar la búsqueda:

SELECT INSTR('That fat cat', 'at', 8)
FROM DUAL;

Resultado:

11

En este caso, la búsqueda comienza en la posición 8, que se encuentra después de las dos primeras apariciones. Por lo tanto, obtenemos la posición del tercer partido.

Especifique qué ocurrencia

Aquí hay un ejemplo de cómo especificar qué ocurrencia buscar:

SELECT INSTR('That fat cat', 'at', 1, 2)
FROM DUAL;

Resultado:

7

En este caso, comenzamos en la posición 1 y luego buscamos la segunda ocurrencia desde esa posición inicial.

Aquí está de nuevo, pero esta vez comparamos tres valores diferentes para la occurrence argumento:

SELECT 
    INSTR('That fat cat', 'at', 1, 1) AS "o1",
    INSTR('That fat cat', 'at', 1, 2) AS "o2",
    INSTR('That fat cat', 'at', 1, 3) AS "o3"
FROM DUAL;

Resultado:

   o1    o2    o3 
_____ _____ _____ 
    3     7    11

Pero esto es lo que sucede si aumentamos la position argumento:

SELECT 
    INSTR('That fat cat', 'at', 5, 1) AS "o1",
    INSTR('That fat cat', 'at', 5, 2) AS "o2",
    INSTR('That fat cat', 'at', 5, 3) AS "o3"
FROM DUAL;

Resultado:

   o1    o2    o3 
_____ _____ _____ 
    7    11     0 

En este caso, no obtenemos la posición de la primera aparición, porque se encuentra antes de nuestra posición inicial. También obtenemos 0 en la tercera columna porque no hay una tercera ocurrencia, según nuestra posición inicial.

Posición negativa

Especificar un valor negativo para la posición hace que la posición inicial se cuente hacia atrás desde el final de la cadena y que Oracle busque hacia atrás desde esa posición:

SELECT INSTR('That fat cat', 'at', -3)
FROM DUAL;

Resultado:

7

Y cualquier ocurrencia que se especifica se cuenta hacia atrás desde esa posición:

SELECT INSTR('That fat cat', 'at', -3, 2)
FROM DUAL;

Resultado:

3

Argumentos nulos

Si alguno (o todos) de los argumentos son null , el resultado es null :

SET NULL 'null';
SELECT 
    INSTR(null, 'f', 1, 1) AS r1,
    INSTR('Coffee', null, 1, 1) AS r2,
    INSTR('Coffee', 'f', null, 1) AS r3,
    INSTR('Coffee', 'f', 1, null) AS r4
FROM DUAL;

Resultado:

     R1      R2      R3      R4 
_______ _______ _______ _______ 
   null    null    null    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.

Recuento de argumentos incorrecto

Llamando a INSTR() sin pasar ningún argumento da como resultado un error:

SELECT INSTR()
FROM DUAL;

Resultado:

Error starting at line : 1 in command -
SELECT 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:

Y pasar demasiados argumentos también da como resultado un error:

SELECT INSTR('Big fat cat', 'at', 1, 2, 3)
FROM DUAL;

Resultado:

Error starting at line : 1 in command -
SELECT INSTR('Big fat cat', 'at', 1, 2, 3)
FROM DUAL
Error at Command Line : 1 Column : 38
Error report -
SQL Error: ORA-00939: too many arguments for function
00939. 00000 -  "too many arguments for function"
*Cause:    
*Action: