INSTR() Funktion i Oracle

I Oracle, INSTR() funktionen söker efter en delsträng i en given sträng och returnerar ett heltal som anger positionen för det första tecknet i denna delsträng. Om delsträngen inte hittas returnerar funktionen 0 .

INSTR() kräver minst två argument; strängen och delsträngen. Den accepterar också ett valfritt tredje och fjärde argument som låter dig ange startpositionen för sökning och vilken förekomst du ska söka efter.

INSTR() kan också ses som en grupp av funktioner. Det finns fem separata funktioner; INSTR() , INSTRB() , INSTRC() , INSTR2() och INSTR4() . Varje funktion beräknar längden på olika sätt.

Syntax

Syntaxen ser ut så här:

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

Där string är strängen att söka, substring är delsträngen att hitta, position är startpositionen för delsträngen och occurrence är vilken händelse man ska hitta.

Funktionerna beräknar längder enligt följande:

Exempel

Här är ett grundläggande exempel:

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

Resultat:

5

Jämfört med INSTRB()

Det här exemplet visar hur resultaten kan skilja sig, beroende på vilken specifik funktion du använder och vilken teckenuppsättning som är involverad.

I det här fallet jämför vi INSTR() med 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;

Resultat:

   INSTR    INSTRB 
________ _________ 
       7         9

Vi kan se att de två funktionerna gav två olika resultat. Detta beror på att vissa tecken i denna sträng använder två byte.

INSTR() funktion returnerar positionen som definieras av den inmatade teckenuppsättningen, medan INSTRB() funktion returnerar positionen baserat i byte .

Om vi ​​återgår till den ursprungliga strängen är resultaten desamma mellan de två funktionerna:

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

Resultat:

   INSTR    INSTRB 
________ _________ 
       5         5 

Det beror på att den här strängen bara använder en byte per tecken, så längden i byte är densamma som antalet tecken.

Startposition

Här är ett exempel som anger positionen för vilken sökningen ska startas:

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

Resultat:

11

I det här fallet börjar sökningen vid position 8, vilket är efter de två första händelserna. Därför får vi positionen för den tredje matchen.

Ange vilken förekomst

Här är ett exempel på hur du anger vilken förekomst som ska hittas:

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

Resultat:

7

I det här fallet började vi på position 1 och sökte sedan efter den andra förekomsten från den startpositionen.

Här är den igen, men den här gången jämför vi tre olika värden för occurrence argument:

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;

Resultat:

   o1    o2    o3 
_____ _____ _____ 
    3     7    11

Men här är vad som händer om vi ökar position argument:

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;

Resultat:

   o1    o2    o3 
_____ _____ _____ 
    7    11     0 

I det här fallet får vi inte positionen för den första händelsen, eftersom den är placerad före vår startposition. Vi får även 0 i den tredje kolumnen eftersom det inte finns någon tredje förekomst, baserat på vår startposition.

Negativ position

Att ange ett negativt värde för positionen gör att startpositionen räknas bakåt från slutet av strängen, och för Oracle att söka bakåt från den positionen:

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

Resultat:

7

Och varje förekomst som anges räknas bakåt från den positionen:

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

Resultat:

3

Nollargument

Om något (eller alla) av argumenten är null , resultatet är 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;

Resultat:

     R1      R2      R3      R4 
_______ _______ _______ _______ 
   null    null    null    null

Som standard returnerar SQLcl och SQL*Plus ett tomt utrymme när null uppstår som ett resultat av en SQL SELECT påstående.

Du kan dock använda SET NULL för att ange en annan sträng som ska returneras. Här specificerade jag att strängen null bör returneras.

Inkorrekt antal argument

Anropar INSTR() utan att skicka några argument resulterar i ett fel:

SELECT INSTR()
FROM DUAL;

Resultat:

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:

Och att skicka för många argument resulterar också i ett fel:

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

Resultat:

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: