Hur PATINDEX()-funktionen fungerar i SQL Server (T-SQL)

I SQL Server kan du använda T-SQL PATINDEX() funktion för att hitta ett mönster i en sträng. Specifikt returnerar funktionen bara den första förekomst av mönstret i strängen.

Funktionen accepterar två argument; mönstret och snöret.

Du kan använda jokertecken i mönstret.

Syntax

Syntaxen ser ut så här:

PATINDEX ( '%pattern%' , expression )

Där mönster är ett teckenuttryck som innehåller sekvensen som ska hittas och uttryck är uttrycket som ska sökas.

Exempel 1 – Grundläggande användning

Här är ett exempel på hur det fungerar:

SELECT PATINDEX('%eer%', 'Bob likes beer.') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 12       |
+----------+

Procenttecknet (% ) är ett jokertecken som representerar en sträng med noll eller fler tecken.

Exempel 2 – Ingen matchning

Det här är vad som händer när vi inte inkluderar jokertecken:

SELECT PATINDEX('eer', 'Bob likes beer.') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 0        |
+----------+

Även om hela strängen matchar mönstret utan jokertecken, får du en matchning:

SELECT PATINDEX('Bob', 'Bob') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 1        |
+----------+

Du kommer dock inte att få en matchning om strängen innehåller fler tecken:

SELECT PATINDEX('Bob', 'Bob likes beer.') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 0        |
+----------+

I så fall kan du använda ett enda jokertecken:

SELECT PATINDEX('Bob%', 'Bob likes beer.') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 1        |
+----------+

Du kan också använda ett enstaka jokertecken någonstans i mitten av mönstret:

SELECT PATINDEX('B%r.', 'Bob likes beer.') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 1        |
+----------+

I det här fallet fick vi en match eftersom början och slutet av strängen matchade början och slutet av mönstret. Mitten av strängen matchade förstås också mitten av mönstret, eftersom alla andra tecken täcks av procenttecknet.

Exempel 3 – Understrecket jokertecken

Här är ett annat exempel där vi introducerar ett annat jokertecken:

SELECT PATINDEX('B_er', 'Beer') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 1        |
+----------+

Understrecket (_ ) som är ett jokertecken för ett enskilt tecken. Därför matchar den bara om det finns exakt ett tecken på den positionen.

Naturligtvis kan mönstret ovan matcha många olika strängar. Till exempel:

SELECT 
  PATINDEX('B_er', 'Beer') AS 'Beer',
  PATINDEX('B_er', 'Bier') AS 'Bier',
  PATINDEX('B_er', 'Baer') AS 'Baer',
  PATINDEX('B_er', 'B er') AS 'B er';

Resultat:

+--------+--------+--------+--------+
| Beer   | Bier   | Baer   | B er   |
|--------+--------+--------+--------|
| 1      | 1      | 1      | 1      |
+--------+--------+--------+--------+

Exempel 4 – Jämföra _ och % Jokertecken

Det här exemplet visar skillnaden mellan _ och % jokertecken.

SELECT 
  PATINDEX('B%r', 'Beer') AS '%',
  PATINDEX('B_r', 'Beer') AS '_',
  PATINDEX('B__r', 'Beer') AS '__';

Resultat:

+-----+-----+------+
| %   | _   | __   |
|-----+-----+------|
| 1   | 0   | 1    |
+-----+-----+------+

Understrecket matchar bara när det finns exakt en karaktär på den positionen. För att matcha två tecken måste vi använda två understreck.

Procenttecknet å andra sidan matchar valfritt antal tecken, inklusive noll, som visas i följande exempel:

SELECT 
  PATINDEX('Bee%r', 'Beer') AS '%',
  PATINDEX('Bee_r', 'Beer') AS '_',
  PATINDEX('Bee__r', 'Beer') AS '__';

Resultat:

+-----+-----+------+
| %   | _   | __   |
|-----+-----+------|
| 1   | 0   | 0    |
+-----+-----+------+

Exempel 5 – Ett databasexempel

Här är ett exempel på hur den här funktionen används i en databasfråga:

USE Music;
SELECT 
  AlbumName,
  PATINDEX('%the%', AlbumName) AS 'Pattern Index'
FROM Albums
WHERE PATINDEX('%the%', AlbumName) > 0;

Resultat:

+-------------------------+-----------------+
| AlbumName               | Pattern Index   |
|-------------------------+-----------------|
| Singing Down the Lane   | 14              |
| Ziltoid the Omniscient  | 9               |
| No Prayer for the Dying | 15              |
| The Sixteen Men of Tain | 1               |
+-------------------------+-----------------+

I det här fallet använder jag WHERE sats för att endast returnera de album som faktiskt matchar, tillsammans med deras PATINDEX() resultat. Om jag tappade WHERE klausul skulle alla album ha returnerats, oavsett om de matchade eller inte.

För de som inte matchade, PATINDEX() resultatet skulle bli noll.

USE Music;
SELECT TOP(10)
  AlbumName,
  PATINDEX('%the%', AlbumName) AS 'Pattern Index'
FROM Albums;

Resultat:

+-------------------------+-----------------+
| AlbumName               | Pattern Index   |
|-------------------------+-----------------|
| Powerslave              | 0               |
| Powerage                | 0               |
| Singing Down the Lane   | 14              |
| Ziltoid the Omniscient  | 9               |
| Casualties of Cool      | 0               |
| Epicloud                | 0               |
| Somewhere in Time       | 0               |
| Piece of Mind           | 0               |
| Killers                 | 0               |
| No Prayer for the Dying | 15              |
+-------------------------+-----------------+

Exempel 6 – Endast första förekomsten

Som nämnts, PATINDEX() returnerar endast den första förekomst av mönstret i strängen.

SELECT PATINDEX('%and%', 'Bob and beer and popcorn.') AS Result;

Resultat:

+----------+
| Result   |
|----------|
| 5        |
+----------+

CHARINDEX() Funktion

T-SQL CHARINDEX() funktionen liknar PATINDEX() . Det finns dock vissa skillnader mellan de två. I synnerhet PATINDEX() accepterar jokertecken, men inte en startposition. CHARINDEX() accepterar å andra sidan en startposition, men inte jokertecken.