Find en streng i en streng i SQL

De fleste af de store DBMS'er giver os en måde at finde en streng i en streng ved hjælp af SQL. Med dette mener jeg brug en SQL-forespørgsel til at finde positionen af en understreng i en streng.

Der er flere SQL-funktioner, der tillader os at gøre dette, inklusive INSTR() , LOCATE() , POSITION() , og CHARINDEX() . Den funktion, du bruger, afhænger af dit DBMS, og muligvis om du skal angive en startposition eller ej.

Oracle

Oracle har en INSTR() funktion, der returnerer startpositionen for en given understreng i en streng.

Eksempel:

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

Resultat:

Dette viser os, at understrengen fat starter ved position 5 i strengen Big fat cat .

Det er muligt at angive en startposition ved at sende et tredje argument. Vi kan også sende et fjerde argument for at specificere, hvilken forekomst der skal findes:

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

Resultat:

I dette tilfælde startede jeg søgningen ved position 1 og søgte efter den anden forekomst (ved at bruge 2 som det fjerde argument).

Oracle har også en INSTRB() funktion, der gør en lignende ting, bortset fra at den returnerer positionen baseret i bytes.

MySQL

MySQL har en INSTR() funktion, der gør noget lignende som Oracle Databases funktion af samme navn:

SELECT INSTR('Cats and dogs like to run', 'dogs');

Resultat:

Men hvis du skal angive en startposition, skal du bruge enten LOCATE() eller POSITION() :

SELECT LOCATE('cat', 'One cat jumped over the other cat', 6);

Resultat:

Her er den første forekomst af cat begynder ved position 5, men jeg specificerede søgningen til at starte ved position 6. Derfor var positionen for den næste forekomst af den streng den, der blev returneret.

Bemærk, at selvom søgningen startede ved position 6, returnerer funktionen stadig understrengens position i strengen – ikke fra startpositionen.

POSITION() funktion er et synonym for to-argumentsyntaksen for LOCATE() , men med en lidt anden syntaks (POSITION() tillader os ikke at angive en startposition).

MySQL har også en REGEX_INSTR() funktion, der returnerer startindekset for understrengen af strengen, der matcher det regulære udtryk specificeret af det angivne mønster.

MariaDB

Ligesom MySQL har MariaDB også en INSTR() funktion, samt en a LOCATE() og POSITION() funktion:

SELECT 
    INSTR('No news is good news', 'news') AS "INSTR",
    POSITION('news' IN 'No news is good news') AS "POSITION",
    LOCATE('news', 'No news is good news') AS "LOCATE 1",
    LOCATE('news', 'No news is good news', 5) AS "LOCATE 2";

Resultat:

+-------+----------+----------+----------+
| INSTR | POSITION | LOCATE 1 | LOCATE 2 |
+-------+----------+----------+----------+
|     4 |        4 |        4 |       17 |
+-------+----------+----------+----------+

MariaDB har også en REGEX_INSTR() funktion, der returnerer startindekset for understrengen af strengen, der matcher det regulære udtryk specificeret af det angivne mønster.

SQL-server

Når det kommer til SQL Server, er CHARINDEX() funktion er det, vi leder efter:

SELECT CHARINDEX('Bob', 'Bob likes beer. Bob also likes beef.', 16);

Resultat:

I dette tilfælde brugte jeg det valgfri tredje argument til at angive en startposition.

SQL Server har også en PATINDEX() funktion, der søger efter et mønster i en streng.

SQLite

SQLite har en INSTR() funktion til at tilfredsstille vores behov:

SELECT INSTR('Black cat', 'lack');

Resultat:

PostgreSQL

I PostgreSQL skal vi bruge POSITION() funktion:

SELECT POSITION('Break' IN 'Bangkok Breaking');

Resultat: