I MariaDB, LIKE operatorn låter dig göra mönstermatchning. Det avgör om en specifik teckensträng matchar ett specificerat mönster. Den returnerar antingen 1 (TRUE) eller 0 (FALSK).
Ett mönster kan innehålla vanliga tecken, såväl som % och _ jokertecken.
Dessa jokertecken förklaras i följande tabell.
| Jokertecken | Beskrivning |
|---|---|
% | Matchar en sträng med noll eller fler tecken. Det kan användas som antingen ett prefix eller ett suffix, och det kan också användas i mitten av en sträng. |
_ | Matchar vilket enskilt tecken som helst. |
Syntax
Syntaxen ser ut så här:
expr LIKE pat [ESCAPE 'escape_char']Exempel
Anta att vi har följande tabell:
SELECT * FROM Pets;Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
Här är ett exempel för att visa hur LIKE operatören fungerar.
SELECT *
FROM Pets
WHERE PetName LIKE 'F%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
I det här exemplet använde jag LIKE operatorn i kombination med % jokerteckenoperatör för att returnera husdjur vars namn börjar med bokstaven F .
Skaftkänslighet
LIKE utför skiftlägesokänsliga delsträngsmatchningar om sorteringen för uttrycket och mönstret är skiftlägesokänslig.
Därför kan vi ändra det föregående exemplet till att använda en liten f , och fortfarande få samma resultat:
SELECT *
FROM Pets
WHERE PetName LIKE 'f%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Vi kan dock tvinga fram en skiftlägeskänslig matchning genom att använda COLLATE sats med en binär sammanställning. Alternativt kan du använda CAST() att tvinga den till en binär sträng.
Exempel:
SELECT *
FROM Pets
WHERE PetName LIKE 'f%' COLLATE utf8_bin;Resultat:
Empty set (0.000 sec)
Inga resultat returneras.
Men om vi ändrar det till en versal F :
SELECT *
FROM Pets
WHERE PetName LIKE 'F%' COLLATE utf8_bin;Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Vi får tre matcher, som väntat.
Numeriska argument
Numeriska argument tvingas till binära strängar.
SELECT *
FROM Pets
WHERE PetId LIKE 7;Resultat:
+-------+-----------+---------+---------+------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------+ | 7 | 3 | 2 | Bark | NULL | +-------+-----------+---------+---------+------+
Datum
Här är ett exempel som matchar året från ett datum:
SELECT *
FROM Pets
WHERE DOB LIKE '2020%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Du kan också använda LIKE operatorn mot resultatet av datumfunktioner, såsom DAYNAME() , MONTHNAME() , etc.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) LIKE 'Nov%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +-------+-----------+---------+---------+------------+
_ Jokertecken-operatör
Understrecket (_ ) jokerteckenoperator matchar vilket enskilt tecken som helst.
Exempel:
SELECT *
FROM Pets
WHERE PetName LIKE '_e%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
I det här fallet matchade vi husdjursnamn där det andra tecknet är en e .
Escape-karaktären
Ibland kan du hamna i den situationen att du behöver söka efter ett understreck eller ett procenttecken. I sådana fall kan du använda ett omvänt snedstreck (\ ) för att undkomma dessa tecken. Detta kommer att förhindra att de tolkas som jokertecken.
Anta att vi har följande tabell:
SELECT * FROM Owners;Resultat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Observera att Ägare 2 (Bart) har en e-postadress som innehåller ett understreck.
Här är ett exempel på vad som händer när vi inte gör det undkomma ett understreck:
SELECT * FROM Owners
WHERE Email LIKE 'b_%';Resultat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
I det här fallet matchade det två rader. I det här fallet spelade det ingen roll vad den andra karaktären var – den matchade alla karaktär. Att den första raden innehåller ett understreck för det andra tecknet är bara en slump. Det hade matchat även om det var något annat.
Men tänk om vi bara ville matcha de e-postadresser som har ett faktiskt understreck som andra tecken?
Det är där flyktkaraktären kommer in.
SELECT * FROM Owners
WHERE Email LIKE 'b\_%';Resultat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Nu får vi bara en rad – raden som innehåller understrecket som andra tecken.
Ändra Escape-karaktären
Det är möjligt att ändra flyktkaraktären. Du kan göra detta med ESCAPE argument.
Exempel:
SELECT * FROM Owners
WHERE Email LIKE 'b*_%' ESCAPE '*';Resultat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
I det här fallet tilldelade jag asterisken (* ) som flykttecken.
Detta kan vara särskilt praktiskt när du behöver använda omvänt snedstreck för andra ändamål, som att koda specialtecken. I sådana fall kan du behöva "dubbel-escape" dessa karaktärer, vilket kan bli förvirrande. Att ändra flyktkaraktären kan därför hjälpa i sådana situationer.
NULL-värden
Procentandelen (% ) jokertecken matchar vad som helst – nästan. En sak som inte matchar är NULL .
SELECT * FROM Owners
WHERE Email LIKE '%';Resultat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
I vår tabell finns det två rader med NULL i Email kolumn, men de returneras inte här.
Prestanda
Frågor som innehåller LIKE operatorn kan köras mycket långsammare än andra frågor, och du bör förmodligen undvika att använda LIKE operatör om du inte verkligen behöver det. Med hjälp av % operator som prefix kan vara särskilt långsam.
Därmed inte sagt att du inte ska använda det alls. LIKE operatör är en integrerad del av SQL, och du kommer att stöta på många scenarier där det kommer att vara det enda alternativet (eller åtminstone det bästa alternativet).
Koden NOT LIKE Operatör
Du kan också använda NOT LIKE för att testa om en sträng inte gör det matcha ett mönster.