In SQL Server puoi utilizzare T-SQL PATINDEX() funzione per trovare un modello all'interno di una stringa. In particolare, la funzione restituisce solo il primo occorrenza del modello all'interno della stringa.
La funzione accetta due argomenti; il modello e la stringa.
Puoi utilizzare caratteri jolly all'interno del modello.
Sintassi
La sintassi è questa:
PATINDEX ( '%pattern%' , expression )
Dove modello è un'espressione di caratteri che contiene la sequenza da trovare e espressione è l'espressione da cercare.
Esempio 1 – Utilizzo di base
Ecco un esempio di come funziona:
SELECT PATINDEX('%eer%', 'Bob likes beer.') AS Result; Risultato:
+----------+ | Result | |----------| | 12 | +----------+
Il segno di percentuale (% ) è un carattere jolly che rappresenta qualsiasi stringa di zero o più caratteri.
Esempio 2 – Nessuna corrispondenza
Ecco cosa succede quando non includiamo i caratteri jolly:
SELECT PATINDEX('eer', 'Bob likes beer.') AS Result; Risultato:
+----------+ | Result | |----------| | 0 | +----------+
Tuttavia, se l'intera stringa corrisponde al modello senza caratteri jolly, otterrai una corrispondenza:
SELECT PATINDEX('Bob', 'Bob') AS Result; Risultato:
+----------+ | Result | |----------| | 1 | +----------+
Tuttavia, non otterrai una corrispondenza se la stringa contiene più caratteri:
SELECT PATINDEX('Bob', 'Bob likes beer.') AS Result; Risultato:
+----------+ | Result | |----------| | 0 | +----------+
In tal caso potresti usare un singolo carattere jolly:
SELECT PATINDEX('Bob%', 'Bob likes beer.') AS Result; Risultato:
+----------+ | Result | |----------| | 1 | +----------+
Potresti anche usare un singolo carattere jolly da qualche parte nel mezzo del pattern:
SELECT PATINDEX('B%r.', 'Bob likes beer.') AS Result; Risultato:
+----------+ | Result | |----------| | 1 | +----------+
In questo caso abbiamo ottenuto una corrispondenza perché l'inizio e la fine della stringa corrispondevano all'inizio e alla fine del pattern. Ovviamente, il centro della stringa corrispondeva anche al centro del pattern, perché tutti gli altri caratteri sono coperti dal segno di percentuale.
Esempio 3 – Il carattere jolly di sottolineatura
Ecco un altro esempio in cui introduciamo un altro carattere jolly:
SELECT PATINDEX('B_er', 'Beer') AS Result; Risultato:
+----------+ | Result | |----------| | 1 | +----------+
Il trattino basso (_ ) che è un carattere jolly per ogni singolo carattere. Pertanto, corrisponderà solo se c'è esattamente un carattere in quella posizione.
Naturalmente, il modello sopra potrebbe corrispondere a molte stringhe diverse. Ad esempio:
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'; Risultato:
+--------+--------+--------+--------+ | Beer | Bier | Baer | B er | |--------+--------+--------+--------| | 1 | 1 | 1 | 1 | +--------+--------+--------+--------+
Esempio 4 – Confronto del _ e % Caratteri jolly
Questo esempio mostra la differenza tra _ e % caratteri jolly.
SELECT
PATINDEX('B%r', 'Beer') AS '%',
PATINDEX('B_r', 'Beer') AS '_',
PATINDEX('B__r', 'Beer') AS '__'; Risultato:
+-----+-----+------+ | % | _ | __ | |-----+-----+------| | 1 | 0 | 1 | +-----+-----+------+
Il trattino basso corrisponde solo quando c'è esattamente un carattere in quella posizione. Per abbinare due caratteri, dobbiamo usare due caratteri di sottolineatura.
Il segno di percentuale, invece, corrisponde a qualsiasi numero di caratteri, incluso lo zero, come mostrato nell'esempio seguente:
SELECT
PATINDEX('Bee%r', 'Beer') AS '%',
PATINDEX('Bee_r', 'Beer') AS '_',
PATINDEX('Bee__r', 'Beer') AS '__'; Risultato:
+-----+-----+------+ | % | _ | __ | |-----+-----+------| | 1 | 0 | 0 | +-----+-----+------+
Esempio 5:un esempio di database
Ecco un esempio di utilizzo di questa funzione in una query di database:
USE Music;
SELECT
AlbumName,
PATINDEX('%the%', AlbumName) AS 'Pattern Index'
FROM Albums
WHERE PATINDEX('%the%', AlbumName) > 0;
Risultato:
+-------------------------+-----------------+ | AlbumName | Pattern Index | |-------------------------+-----------------| | Singing Down the Lane | 14 | | Ziltoid the Omniscient | 9 | | No Prayer for the Dying | 15 | | The Sixteen Men of Tain | 1 | +-------------------------+-----------------+
In questo caso utilizzo il WHERE clausola per restituire solo gli album che effettivamente corrispondono, insieme al loro PATINDEX() risultato. Se ho lasciato cadere il WHERE clausola, tutti gli album sarebbero stati restituiti, indipendentemente dal fatto che corrispondessero o meno.
Per quelli che non corrispondono, il PATINDEX() il risultato sarebbe zero.
USE Music;
SELECT TOP(10)
AlbumName,
PATINDEX('%the%', AlbumName) AS 'Pattern Index'
FROM Albums;
Risultato:
+-------------------------+-----------------+ | 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 | +-------------------------+-----------------+
Esempio 6 – Solo prima occorrenza
Come accennato, PATINDEX() restituisce solo il primo occorrenza del modello all'interno della stringa.
SELECT PATINDEX('%and%', 'Bob and beer and popcorn.') AS Result; Risultato:
+----------+ | Result | |----------| | 5 | +----------+
Il CHARINDEX() Funzione
Il CHARINDEX() di T-SQL la funzione è simile a PATINDEX() . Tuttavia, ci sono alcune differenze tra i due. In particolare, il PATINDEX() accetta caratteri jolly, ma non una posizione iniziale. CHARINDEX() accetta invece una posizione di partenza, ma non caratteri jolly.
