Fonction INSTR() dans Oracle

Dans Oracle, le INSTR() La fonction recherche une sous-chaîne dans une chaîne donnée, et retourne un entier indiquant la position du premier caractère de cette sous-chaîne. Si la sous-chaîne n'est pas trouvée, la fonction renvoie 0 .

INSTR() nécessite au moins deux arguments ; la chaîne et la sous-chaîne. Il accepte également un troisième et un quatrième arguments facultatifs qui vous permettent de spécifier la position de départ à rechercher et l'occurrence à rechercher.

INSTR() peut également être considéré comme un ensemble de fonctions. Il y a cinq fonctions distinctes ; INSTR() , INSTRB() , INSTRC() , INSTR2() , et INSTR4() . Chaque fonction calcule la longueur d'une manière différente.

Syntaxe

La syntaxe ressemble à ceci :

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

Où string est la chaîne à rechercher, substring est la sous-chaîne à rechercher, position est la position de départ de la sous-chaîne, et occurrence est quelle occurrence rechercher.

Les fonctions calculent les longueurs comme suit :

Exemple

Voici un exemple de base :

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

Résultat :

5

Par rapport à INSTRB()

Cet exemple montre comment les résultats peuvent différer, selon la fonction spécifique que vous utilisez et le jeu de caractères impliqué.

Dans ce cas, nous comparons INSTR() avec 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;

Résultat :

   INSTR    INSTRB 
________ _________ 
       7         9

Nous pouvons voir que les deux fonctions ont renvoyé deux résultats différents. Cela est dû au fait que certains caractères de cette chaîne utilisent deux octets.

Le INSTR() La fonction renvoie la position telle que définie par le jeu de caractères d'entrée, alors que la fonction INSTRB() la fonction renvoie la position en octets .

Si nous revenons à la chaîne d'origine, les résultats sont les mêmes entre les deux fonctions :

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

Résultat :

   INSTR    INSTRB 
________ _________ 
       5         5 

C'est parce que cette chaîne utilise un seul octet par caractère, et donc la longueur en octets est la même que le nombre de caractères.

Position de départ

Voici un exemple qui spécifie la position pour laquelle lancer la recherche :

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

Résultat :

11

Dans ce cas, la recherche commence à la position 8, qui est après les deux premières occurrences. Par conséquent, nous obtenons la position du troisième match.

Spécifier quelle occurrence

Voici un exemple de spécification de l'occurrence à rechercher :

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

Résultat :

7

Dans ce cas, nous avons commencé à la position 1, puis avons recherché la deuxième occurrence à partir de cette position de départ.

Le voici à nouveau, mais cette fois nous comparons trois valeurs différentes pour l'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;

Résultat :

   o1    o2    o3 
_____ _____ _____ 
    3     7    11

Mais voici ce qui se passe si nous augmentons la 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;

Résultat :

   o1    o2    o3 
_____ _____ _____ 
    7    11     0 

Dans ce cas, nous n'obtenons pas la position de la première occurrence, car elle est située avant notre position de départ. Nous obtenons également 0 dans la troisième colonne car il n'y a pas de troisième occurrence, en fonction de notre position de départ.

Position négative

Si vous spécifiez une valeur négative pour la position, la position de départ est comptée à rebours à partir de la fin de la chaîne, et Oracle effectue une recherche à rebours à partir de cette position :

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

Résultat :

7

Et toute occurrence spécifiée est comptée à rebours à partir de cette position :

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

Résultat :

3

Arguments nuls

Si l'un (ou tous) des arguments est null , le résultat est 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;

Résultat :

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

Par défaut, SQLcl et SQL*Plus renvoient un espace vide chaque fois que null se produit à la suite d'un SQL SELECT déclaration.

Cependant, vous pouvez utiliser SET NULL pour spécifier une autre chaîne à renvoyer. Ici, j'ai précisé que la chaîne null doit être retourné.

Nombre d'arguments incorrects

Appel de INSTR() sans passer d'arguments entraîne une erreur :

SELECT INSTR()
FROM DUAL;

Résultat :

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:

Et passer trop d'arguments entraîne également une erreur :

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

Résultat :

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: