No SQL Server, você pode usar o T-SQL
PATINDEX() função para encontrar um padrão dentro de uma string. Especificamente, a função retorna apenas o primeiro ocorrência do padrão dentro da string. A função aceita dois argumentos; o padrão e a corda.
Você pode usar caracteres curinga dentro do padrão.
Sintaxe
A sintaxe fica assim:
PATINDEX ( '%pattern%' , expression )
Onde padrão é uma expressão de caracteres que contém a sequência a ser encontrada e expressão é a expressão a ser pesquisada.
Exemplo 1 – Uso básico
Veja um exemplo de como funciona:
SELECT PATINDEX('%eer%', 'Bob likes beer.') AS Result; Resultado:
+----------+ | Result | |----------| | 12 | +----------+
O sinal de porcentagem (
% ) é um caractere curinga que representa qualquer cadeia de zero ou mais caracteres. Exemplo 2 – Sem correspondência
Veja o que acontece quando não incluímos os caracteres curinga:
SELECT PATINDEX('eer', 'Bob likes beer.') AS Result; Resultado:
+----------+ | Result | |----------| | 0 | +----------+
Embora, se a string completa corresponder ao padrão sem curingas, você obterá uma correspondência:
SELECT PATINDEX('Bob', 'Bob') AS Result; Resultado:
+----------+ | Result | |----------| | 1 | +----------+
No entanto, você não obterá uma correspondência se a string contiver mais caracteres:
SELECT PATINDEX('Bob', 'Bob likes beer.') AS Result; Resultado:
+----------+ | Result | |----------| | 0 | +----------+
Nesse caso, você pode usar um único curinga:
SELECT PATINDEX('Bob%', 'Bob likes beer.') AS Result; Resultado:
+----------+ | Result | |----------| | 1 | +----------+
Você também pode usar um único curinga em algum lugar no meio do padrão:
SELECT PATINDEX('B%r.', 'Bob likes beer.') AS Result; Resultado:
+----------+ | Result | |----------| | 1 | +----------+
Nesse caso, obtivemos uma correspondência porque o início e o final da string corresponderam ao início e ao final do padrão. Obviamente, o meio da string também corresponde ao meio do padrão, porque todos os outros caracteres são cobertos pelo sinal de porcentagem.
Exemplo 3 – O curinga sublinhado
Aqui está outro exemplo em que introduzimos outro caractere curinga:
SELECT PATINDEX('B_er', 'Beer') AS Result; Resultado:
+----------+ | Result | |----------| | 1 | +----------+
O sublinhado (
_ ) que é um curinga para qualquer caractere único. Portanto, ele só corresponderá se houver exatamente um caractere nessa posição. Obviamente, o padrão acima pode corresponder a muitas strings diferentes. Por exemplo:
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'; Resultado:
+--------+--------+--------+--------+ | Beer | Bier | Baer | B er | |--------+--------+--------+--------| | 1 | 1 | 1 | 1 | +--------+--------+--------+--------+
Exemplo 4 – Comparando o _ e % Curingas
Este exemplo demonstra a diferença entre o
_ e % caracteres curinga. SELECT
PATINDEX('B%r', 'Beer') AS '%',
PATINDEX('B_r', 'Beer') AS '_',
PATINDEX('B__r', 'Beer') AS '__'; Resultado:
+-----+-----+------+ | % | _ | __ | |-----+-----+------| | 1 | 0 | 1 | +-----+-----+------+
O sublinhado só corresponde quando há exatamente um caractere nessa posição. Para combinar dois caracteres, precisamos usar dois sublinhados.
O sinal de porcentagem, por outro lado, corresponde a qualquer número de caracteres, incluindo zero, conforme visto no exemplo a seguir:
SELECT
PATINDEX('Bee%r', 'Beer') AS '%',
PATINDEX('Bee_r', 'Beer') AS '_',
PATINDEX('Bee__r', 'Beer') AS '__'; Resultado:
+-----+-----+------+ | % | _ | __ | |-----+-----+------| | 1 | 0 | 0 | +-----+-----+------+
Exemplo 5 – Um exemplo de banco de dados
Aqui está um exemplo de uso desta função em uma consulta de banco de dados:
USE Music;
SELECT
AlbumName,
PATINDEX('%the%', AlbumName) AS 'Pattern Index'
FROM Albums
WHERE PATINDEX('%the%', AlbumName) > 0;
Resultado:
+-------------------------+-----------------+ | AlbumName | Pattern Index | |-------------------------+-----------------| | Singing Down the Lane | 14 | | Ziltoid the Omniscient | 9 | | No Prayer for the Dying | 15 | | The Sixteen Men of Tain | 1 | +-------------------------+-----------------+
Neste caso eu uso o
WHERE cláusula para retornar apenas os álbuns que realmente correspondem, juntamente com seus PATINDEX() resultado. Se eu soltar o WHERE cláusula, todos os álbuns seriam devolvidos, independentemente de corresponderem ou não. Para aqueles que não corresponderam, o
PATINDEX() resultado seria zero. USE Music;
SELECT TOP(10)
AlbumName,
PATINDEX('%the%', AlbumName) AS 'Pattern Index'
FROM Albums;
Resultado:
+-------------------------+-----------------+ | 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 | +-------------------------+-----------------+
Exemplo 6 – Somente a primeira ocorrência
Como mencionado,
PATINDEX() retorna apenas o primeiro ocorrência do padrão dentro da string. SELECT PATINDEX('%and%', 'Bob and beer and popcorn.') AS Result; Resultado:
+----------+ | Result | |----------| | 5 | +----------+
O CHARINDEX() Função
O T-SQL
CHARINDEX() função é semelhante a PATINDEX() . No entanto, existem algumas diferenças entre os dois. Em particular, o PATINDEX() aceita caracteres curinga, mas não uma posição inicial. CHARINDEX() por outro lado, aceita uma posição inicial, mas não caracteres curinga. 
