Hitta en sträng i en sträng i SQL

De flesta av de stora DBMS:erna ger oss ett sätt att hitta en sträng i en sträng med hjälp av SQL. Med detta menar jag att använda en SQL-fråga för att hitta positionen för en delsträng i en sträng.

Det finns flera SQL-funktioner som tillåter oss att göra detta, inklusive INSTR() , LOCATE() , POSITION() , och CHARINDEX() . Vilken funktion du använder beror på ditt DBMS och eventuellt om du behöver ange en startposition eller inte.

Oracle

Oracle har en INSTR() funktion som returnerar startpositionen för en given delsträng i en sträng.

Exempel:

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

Resultat:

Detta visar oss att delsträngen fat börjar på position 5 i strängen Big fat cat .

Det är möjligt att ange en startposition genom att skicka ett tredje argument. Vi kan också skicka ett fjärde argument för att specificera vilken förekomst som ska hittas:

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

Resultat:

I det här fallet startade jag sökningen vid position 1 och sökte efter den andra förekomsten (genom att använda 2 som fjärde argument).

Oracle har också en INSTRB() funktion som gör en liknande sak, förutom att den returnerar positionen baserat i byte.

MySQL

MySQL har en INSTR() funktion som gör något liknande Oracle Databases funktion med samma namn:

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

Resultat:

Men om du behöver ange en startposition måste du använda antingen LOCATE() eller POSITION() :

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

Resultat:

Här är den första förekomsten av cat börjar vid position 5, men jag angav att sökningen skulle börja vid position 6. Därför var positionen för nästa förekomst av den strängen den som returnerades.

Observera att även om sökningen startade vid position 6, returnerar funktionen fortfarande understrängens position inom strängen – inte från startpositionen.

POSITION() funktion är en synonym för syntaxen med två argument för LOCATE() , men med en något annorlunda syntax (POSITION() tillåter oss inte att ange en startposition).

MySQL har också en REGEX_INSTR() funktion som returnerar startindexet för delsträngen av strängen som matchar det reguljära uttrycket som anges av det angivna mönstret.

MariaDB

Precis som MySQL har MariaDB också en INSTR() funktion, samt en a LOCATE() och 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 också en REGEX_INSTR() funktion som returnerar startindexet för delsträngen av strängen som matchar det reguljära uttrycket som anges av det angivna mönstret.

SQL-server

När det gäller SQL Server, CHARINDEX() funktion är vad vi letar efter:

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

Resultat:

I det här fallet använde jag det valfria tredje argumentet för att ange en startposition.

SQL Server har också en PATINDEX() funktion som söker efter ett mönster i en sträng.

SQLite

SQLite har en INSTR() funktion för att tillfredsställa våra behov:

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

Resultat:

PostgreSQL

I PostgreSQL måste vi använda POSITION() funktion:

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

Resultat: