In MariaDB, de NOT LIKE operator wordt gebruikt om te testen of een string al dan niet niet overeenkomen met een patroon. Het retourneert de inverse van de LIKE exploitant. Het is hetzelfde als het toepassen van de NOT operator tegen de hele LIKE uitdrukking.
Een patroon kan gewone tekens bevatten, evenals de % en _ jokertekens.
Die jokertekens worden uitgelegd in de volgende tabel.
| Wildcard-teken | Beschrijving |
|---|---|
% | Komt overeen met elke tekenreeks van nul of meer tekens. Het kan worden gebruikt als voorvoegsel of achtervoegsel, en het kan ook in het midden van een tekenreeks worden gebruikt. |
_ | Komt overeen met elk afzonderlijk teken. |
Syntaxis
De syntaxis gaat als volgt:
expr NOT LIKE pat [ESCAPE 'escape_char']Voorbeeld
Stel dat we de volgende tabel hebben:
SELECT * FROM Pets;Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Hier is een voorbeeld van het gebruik van NOT LIKE tegen die tafel:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
In dit voorbeeld heb ik NOT LIKE . gebruikt in combinatie met de % wildcard-operator om huisdieren te retourneren wiens naam niet begin met de letter F .
Dit is de tegenovergestelde resultaatset die we zouden hebben gekregen als we gewoon LIKE hadden gebruikt . In dat geval zouden we alleen resultaten krijgen als de naam van het huisdier begint met de letter F .
Hoofdlettergevoeligheid
NOT LIKE voert hoofdletterongevoelige subtekenreeksovereenkomsten uit als de sortering voor de uitdrukking en het patroon hoofdletterongevoelig is.
Daarom kunnen we het vorige voorbeeld wijzigen om een kleine letter f . te gebruiken , en krijg nog steeds hetzelfde resultaat:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%';Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
We kunnen echter een hoofdlettergevoelige overeenkomst forceren met behulp van de COLLATE clausule met een binaire sortering. Als alternatief kunt u CAST() . gebruiken om het te dwingen tot een binaire string.
Voorbeeld:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%' COLLATE utf8_bin;Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Deze keer werd de hele tafel teruggebracht. Dit komt omdat niets overeenkwam met de kleine letter f .
Maar als we het veranderen in een hoofdletter F :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
We krijgen vijf wedstrijden, zoals verwacht. De rijen waar de naam van het huisdier begint met F zijn uitgesloten.
Numerieke argumenten
Numerieke argumenten worden gedwongen tot binaire strings.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Datums
Hier is een datumvoorbeeld:
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Resultaat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
Je kunt ook de NOT LIKE . gebruiken operator tegen het resultaat van datumfuncties, zoals DAYNAME() , MONTHNAME() , enz.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
De _ Wildcard-operator
Het onderstrepingsteken (_ ) jokertekenoperator komt overeen met elk afzonderlijk teken.
Voorbeeld:
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
In dit geval hebben we koosnaampjes geretourneerd waarbij het tweede teken niet . is een e .
Het ontsnappingspersonage
Soms bevindt u zich in de situatie waarin u moet zoeken naar een onderstrepingsteken of een percentageteken. In dergelijke gevallen kunt u een backslash gebruiken (\ ) om aan deze tekens te ontsnappen. Dit voorkomt dat ze worden geïnterpreteerd als jokertekens.
Stel dat we de volgende tabel hebben:
SELECT * FROM Owners;Resultaat:
+---------+-----------+----------+----------------+--------------------+ | 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] | +---------+-----------+----------+----------------+--------------------+
Merk op dat Eigenaar 2 (Bart) een e-mailadres heeft dat een onderstrepingsteken bevat.
Hier is een voorbeeld van wat er gebeurt als we niet ontsnappen aan een onderstrepingsteken:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b_%';Resultaat:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
In dit geval heeft het slechts twee rijen geretourneerd. Het sloot de twee rijen uit waar het e-mailadres begint met een b , en wordt gevolgd door een ander teken en vervolgens een willekeurig aantal tekens. Het sloot ook de rijen uit met een null e-mailadres.
Omdat we echter niet aan het onderstrepingsteken ontsnapten, maakte het niet uit wat het tweede teken was - het kwam overeen met elke karakter. Het feit dat de eerste rij een onderstrepingsteken voor het tweede teken bevat, is puur toeval. Zelfs als het iets anders was, zou het overeen komen.
Maar wat als we alleen die e-mailadressen wilden matchen die een echt onderstrepingsteken als tweede teken hebben?
Dat is waar het ontsnappingskarakter om de hoek komt kijken.
SELECT * FROM Owners
WHERE Email NOT LIKE 'b\_%';Resultaat:
+---------+-----------+----------+----------------+-------------------+ | 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] | +---------+-----------+----------+----------------+-------------------+
We kunnen zien dat Burt is toegevoegd aan de resultaten.
Het Escape-teken wijzigen
Het is mogelijk om het escape-teken te wijzigen. U kunt dit doen met de ESCAPE argument.
Voorbeeld:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b*_%' ESCAPE '*';Resultaat:
+---------+-----------+----------+----------------+-------------------+ | 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] | +---------+-----------+----------+----------------+-------------------+
In dit geval heb ik de asterisk (* ) als het escape-teken.
Dit kan handig zijn wanneer u de backslash voor andere doeleinden moet gebruiken, zoals het coderen van speciale tekens. In dergelijke gevallen kan het zijn dat u deze tekens moet 'dubbel-ontsnappen', wat verwarrend kan worden. Het veranderen van het escape-teken kan daarom helpen in dergelijke situaties.