En SQLite, puede usar LIKE operador en sus consultas para hacer una comparación de coincidencia de patrones.
Por ejemplo, puede agregarlo a su WHERE cláusula para devolver solo filas que coincidan con un patrón dado.
Sin embargo, agregarlo a WHERE La cláusula no es la única forma en que puede usar LIKE operador. También puede usarlo para devolver un valor booleano.
Ejemplo básico
Aquí hay un ejemplo básico que usa LIKE operador en un WHERE cláusula.
SELECT * FROM Artist
WHERE Name LIKE 'Black%';Resultado:
ArtistId Name ---------- ------------------- 11 Black Label Society 12 Black Sabbath 169 Black Eyed Peas
En este caso, quería devolver a todos los artistas cuyos nombres comienzan con Black .
El signo de porcentaje es un carácter comodín que coincide con cero o más de cualquier carácter (incluidos los espacios).
Sin el comodín
Si no hubiera usado el carácter comodín, no habría obtenido ningún resultado.
He aquí un ejemplo de lo que quiero decir:
SELECT * FROM Artist
WHERE Name LIKE 'Black';Resultado:
(Eso está intencionalmente en blanco, porque no hubo resultados).
Múltiples comodines
Puede utilizar más de un carácter comodín si es necesario. En este ejemplo, agrego otro al frente de mi patrón.
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
Esto da como resultado que se devuelvan más filas, porque hay dos filas que tienen Negro en su nombre, pero no al principio.
El guión bajo (_) comodín
También tiene la opción de usar el guión bajo (_ ) comodín.
Este carácter comodín coincide exactamente con un carácter (cualquier carácter).
Considere la siguiente tabla llamada Cats :
CatId CatName ---------- ---------- 1 Brush 2 Brash 3 Broosh 4 100%Fluff 5 100$Fluff
Sí, algunos de esos gatos tienen nombres extraños, pero serán útiles.
Este es un ejemplo del uso del comodín de subrayado en una consulta en esa tabla.
SELECT * FROM Cats
WHERE CatName LIKE 'Br_sh';Resultado:
CatId CatName ---------- ---------- 1 Brush 2 Brash
Observe que el gato llamado Broosh no está incluido.
Para incluir Broosh , necesitaría usar dos guiones bajos:
SELECT * FROM Cats
WHERE CatName LIKE 'Br__sh';Resultado:
CatId CatName ---------- ---------- 3 Broosh
Sin embargo, esto excluye a los otros dos gatos.
Siempre podría usar un signo de porcentaje para incluir a los otros gatos.
SELECT * FROM Cats
WHERE CatName LIKE 'Br%sh';Resultado:
CatId CatName ---------- ---------- 1 Brush 2 Brash 3 Broosh
Aunque tenga en cuenta que esto también devolvería nombres con más de dos caracteres entre Br y sh .
La cláusula de ESCAPE
A veces, sus datos pueden incluir los caracteres comodín. En otras palabras, los datos contienen guiones bajos o signos de porcentaje.
Esto podría ser un problema si realmente está tratando de hacer coincidir el guión bajo o el signo de porcentaje como un carácter literal y no como un comodín.
En mi tabla de gatos, notará que un gato tiene un signo de porcentaje en su nombre. Otro gato tiene casi exactamente el mismo nombre, excepto que, en lugar de un signo de porcentaje, es un signo de dólar.
Aquí está la tabla de nuevo:
CatId CatName ---------- ---------- 1 Brush 2 Brash 3 Broosh 4 100%Fluff 5 100$Fluff
Si quisiera devolver solo aquellos gatos cuyos nombres comienzan con 100%F entonces necesitaría escapar del % . Si no me escapaba de esto, obtendría resultados no deseados.
Esto es lo que sucede si ejecuto una consulta sin escapando del signo de porcentaje.
SELECT * FROM Cats
WHERE CatName LIKE '100%F';Resultado:
CatId CatName ---------- ---------- 4 100%Fluff 5 100$Fluff
En este caso, el signo de porcentaje también coincidía con el signo de dólar, porque el signo de porcentaje se trataba como un carácter comodín.
Para asegurarnos de que el signo de porcentaje no se trate como un carácter comodín, podemos usar el ESCAPE cláusula.
SELECT * FROM Cats
WHERE CatName LIKE '100\%%F' ESCAPE '\';Resultado:
CatId CatName ---------- ---------- 4 100%Fluff
Devolver un valor booleano
Puedes usar el LIKE operador para devolver un 0 o 1 , dependiendo de si hay una coincidencia o no.
He aquí un ejemplo.
SELECT
CatName,
CatName LIKE 'Br%'
FROM Cats;Resultado:
CatName CatName LIKE 'Br%' ---------- ------------------ Brush 1 Brash 1 Broosh 1 100%Fluff 0 100$Fluff 0
En este caso, las tres primeras filas coinciden con los criterios y las dos últimas filas no.
Sensible a mayúsculas y minúsculas
De forma predeterminada, SQLite LIKE El operador no distingue entre mayúsculas y minúsculas para los caracteres ASCII. Esto significa que coincidirá con los caracteres en mayúsculas y minúsculas, independientemente de las mayúsculas y minúsculas que utilice en su patrón.
Puede usar el case_Sensible_like Declaración PRAGMA para realizar coincidencias entre mayúsculas y minúsculas en el rango ASCII.
Consulte Cómo hacer que el operador LIKE de SQLite distinga entre mayúsculas y minúsculas para ver ejemplos.
Función Me gusta()
Una forma alternativa de hacerlo es usar like() función.
Esta función hace exactamente lo mismo que LIKE operador, excepto que necesita usar una sintaxis ligeramente diferente.
Todos los ejemplos anteriores podrían reescribirse para usar like() función si es necesario.
