No SQLite, você pode usar o
LIKE operador em suas consultas para fazer uma comparação de correspondência de padrões. Por exemplo, você pode adicioná-lo ao seu
WHERE cláusula para retornar apenas as linhas que correspondem a um determinado padrão. No entanto, adicioná-lo ao
WHERE cláusula não é a única maneira que você pode usar o LIKE operador. Você também pode usá-lo para retornar um valor booleano. Exemplo básico
Aqui está um exemplo básico que usa o
LIKE operador em um WHERE cláusula. SELECT * FROM Artist
WHERE Name LIKE 'Black%';Resultado:
ArtistId Name ---------- ------------------- 11 Black Label Society 12 Black Sabbath 169 Black Eyed Peas
Neste caso, eu queria devolver todos os artistas cujos nomes começam com Black .
O sinal de porcentagem é um caractere curinga que corresponde a zero ou mais de qualquer caractere (incluindo espaços).
Sem o curinga
Se eu não tivesse usado o caractere curinga, não teria obtido nenhum resultado.
Aqui está um exemplo do que quero dizer:
SELECT * FROM Artist
WHERE Name LIKE 'Black';Resultado:
(Isso está intencionalmente em branco, porque não houve resultados.)
Vários curingas
Você pode usar mais de um caractere curinga, se necessário. Neste exemplo, adiciono outro à frente do meu padrão.
SELECT * FROM Artist
WHERE Name LIKE '%Black%';Resultado:
ArtistId Name ---------- ------------------- 11 Black Label Society 12 Black Sabbath 38 Banda Black Rio 137 The Black Crowes 169 Black Eyed Peas
Isso resulta no retorno de mais linhas, pois há duas linhas com Preto em seu nome, mas não apenas no início.
O caractere curinga de sublinhado (_)
Você também tem a opção de usar o sublinhado (
_ ) curinga. Este caractere curinga corresponde exatamente a um caractere (qualquer caractere).
Considere a seguinte tabela chamada Gatos :
CatId CatName ---------- ---------- 1 Brush 2 Brash 3 Broosh 4 100%Fluff 5 100$Fluff
Sim, alguns desses gatos têm nomes estranhos, mas serão úteis.
Aqui está um exemplo de uso do caractere curinga de sublinhado em uma consulta nessa tabela.
SELECT * FROM Cats
WHERE CatName LIKE 'Br_sh';Resultado:
CatId CatName ---------- ---------- 1 Brush 2 Brash
Observe que o gato chamado Broosh não está incluído.
Para incluir Broosh , eu precisaria usar dois sublinhados:
SELECT * FROM Cats
WHERE CatName LIKE 'Br__sh';Resultado:
CatId CatName ---------- ---------- 3 Broosh
No entanto, isso exclui os outros dois gatos.
Eu sempre poderia usar um sinal de porcentagem para incluir os outros gatos.
SELECT * FROM Cats
WHERE CatName LIKE 'Br%sh';Resultado:
CatId CatName ---------- ---------- 1 Brush 2 Brash 3 Broosh
No entanto, lembre-se de que isso também retornaria nomes com mais de dois caracteres entre Br e sh .
A Cláusula ESCAPE
Às vezes, seus dados podem incluir os caracteres curinga. Em outras palavras, os dados contêm sublinhados ou sinais de porcentagem.
Isso pode ser um problema se você estiver realmente tentando corresponder o sublinhado ou o sinal de porcentagem como um caractere literal e não como um curinga.
Na minha tabela de gatos, você notará que um gato tem um sinal de porcentagem em seu nome. Outro gato tem quase exatamente o mesmo nome, exceto que, em vez de um sinal de porcentagem, é um cifrão.
Aqui está a tabela novamente:
CatId CatName ---------- ---------- 1 Brush 2 Brash 3 Broosh 4 100%Fluff 5 100$Fluff
Se eu quisesse retornar apenas aqueles gatos cujos nomes começam com 100%F então eu precisaria escapar do % . Se eu não escapasse disso, obteria resultados indesejados.
Veja o que acontece se eu executar uma consulta sem escapando do sinal de porcentagem.
SELECT * FROM Cats
WHERE CatName LIKE '100%F';Resultado:
CatId CatName ---------- ---------- 4 100%Fluff 5 100$Fluff
Nesse caso, o sinal de porcentagem também correspondeu ao cifrão, porque o sinal de porcentagem estava sendo tratado como um caractere curinga.
Para garantir que o sinal de porcentagem não seja tratado como um caractere curinga, podemos usar o
ESCAPE cláusula. SELECT * FROM Cats
WHERE CatName LIKE '100\%%F' ESCAPE '\';Resultado:
CatId CatName ---------- ---------- 4 100%Fluff
Retorne um valor booleano
Você pode usar o
LIKE operador para retornar um 0 ou 1 , dependendo se há uma correspondência ou não. Aqui está um exemplo.
SELECT
CatName,
CatName LIKE 'Br%'
FROM Cats;Resultado:
CatName CatName LIKE 'Br%' ---------- ------------------ Brush 1 Brash 1 Broosh 1 100%Fluff 0 100$Fluff 0
Nesse caso, as três primeiras linhas correspondem aos critérios e as duas últimas linhas não.
Sensibilidade a maiúsculas e minúsculas
Por padrão, o SQLite
LIKE operador não diferencia maiúsculas de minúsculas para caracteres ASCII. Isso significa que ele corresponderá a caracteres maiúsculos e minúsculos, independentemente de qual maiúscula você usar em seu padrão. Você pode usar o case_sensitive_like Instrução PRAGMA para realizar correspondências que diferenciam maiúsculas de minúsculas no intervalo ASCII.
Veja Como tornar o operador LIKE do SQLite sensível a maiúsculas e minúsculas para obter exemplos.
A função Like()
Uma maneira alternativa de fazer isso é usar o
like() função. Esta função faz exatamente a mesma coisa que o
LIKE operador, exceto que você precisa usar uma sintaxe ligeiramente diferente. Todos os exemplos acima podem ser reescritos para usar o
like() função, se necessário. 
