I MariaDB, NOT LIKE operatorn används för att testa om en sträng inte gör det eller inte matcha ett mönster. Den returnerar inversen av LIKE operatör. Det är samma sak som att använda NOT operatorn mot hela LIKE uttryck.
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 NOT 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 på hur du använder NOT LIKE mot den tabellen:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
I det här exemplet använde jag NOT LIKE i kombination med % jokerteckenoperatör för att returnera husdjur vars namn inte gör det börja med bokstaven F .
Det här är den motsatta resultatuppsättningen vi skulle ha fått om vi bara hade använt LIKE . I så fall skulle vi bara få resultat där husdjurets namn börjar med bokstaven F .
Skaftkänslighet
NOT 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 NOT LIKE 'f%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
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 NOT 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 | | 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 | +-------+-----------+---------+---------+------------+
Den här gången gavs hela bordet tillbaka. Detta beror på att ingenting matchade gemena f .
Men om vi ändrar det till en versal F :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
Vi får fem matcher, som väntat. Raderna där husdjursnamnet börjar med F är uteslutna.
Numeriska argument
Numeriska argument tvingas till binära strängar.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Datum
Här är ett datumexempel:
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
Du kan också använda koden NOT LIKE operatorn mot resultatet av datumfunktioner, såsom DAYNAME() , MONTHNAME() , etc.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
_ Jokertecken-operatör
Understrecket (_ ) jokerteckenoperator matchar vilket enskilt tecken som helst.
Exempel:
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Resultat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 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 | +-------+-----------+---------+---------+------------+
I det här fallet returnerade vi husdjursnamn där det andra tecknet är inte 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 NOT LIKE 'b_%';Resultat:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
I det här fallet returnerade den bara två rader. Det exkluderade de två raderna där e-postadressen börjar med b , och följs av ett annat tecken och sedan valfritt antal tecken. Det exkluderade också raderna med en null e-postadress.
Men eftersom vi inte undgick understrecket 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 NOT LIKE 'b\_%';Resultat:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
Vi kan se att Burt har lagts till i resultaten.
Ä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 NOT LIKE 'b*_%' ESCAPE '*';Resultat:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
I det här fallet tilldelade jag asterisken (* ) som flykttecken.
Detta kan vara 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.