In MariaDB, de LIKE operator stelt u in staat om patroonafstemming uit te voeren. Het bepaalt of een specifieke tekenreeks overeenkomt met een bepaald patroon. Het retourneert ofwel 1 (TRUE) of 0 (VALS).
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 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 om te demonstreren hoe de LIKE exploitant werkt.
SELECT *
FROM Pets
WHERE PetName LIKE 'F%';Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
In dit voorbeeld heb ik de LIKE . gebruikt operator in combinatie met de % wildcard-operator om huisdieren te retourneren waarvan de naam begint met de letter F .
Hoofdlettergevoeligheid
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 LIKE 'f%';Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
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 LIKE 'f%' COLLATE utf8_bin;Resultaat:
Empty set (0.000 sec)
Er worden geen resultaten geretourneerd.
Maar als we het veranderen in een hoofdletter F :
SELECT *
FROM Pets
WHERE PetName 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 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
We krijgen drie wedstrijden, zoals verwacht.
Numerieke argumenten
Numerieke argumenten worden gedwongen tot binaire strings.
SELECT *
FROM Pets
WHERE PetId LIKE 7;Resultaat:
+-------+-----------+---------+---------+------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------+ | 7 | 3 | 2 | Bark | NULL | +-------+-----------+---------+---------+------+
Datums
Hier is een voorbeeld dat overeenkomt met het jaar vanaf een datum:
SELECT *
FROM Pets
WHERE DOB LIKE '2020%';Resultaat:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Je kunt ook de LIKE . gebruiken operator tegen het resultaat van datumfuncties, zoals DAYNAME() , MONTHNAME() , enz.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) LIKE 'Nov%';Resultaat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +-------+-----------+---------+---------+------------+
De _ Wildcard-operator
Het onderstrepingsteken (_ ) jokertekenoperator komt overeen met elk afzonderlijk teken.
Voorbeeld:
SELECT *
FROM Pets
WHERE PetName LIKE '_e%';Resultaat:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
In dit geval hebben we namen van huisdieren gevonden waarbij het tweede teken een e . is .
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 LIKE 'b_%';Resultaat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
In dit geval kwam het overeen met twee rijen. In dit geval 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 LIKE 'b\_%';Resultaat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Nu krijgen we maar één rij – de rij met het onderstrepingsteken als tweede teken.
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 LIKE 'b*_%' ESCAPE '*';Resultaat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
In dit geval heb ik de asterisk (* ) als het escape-teken.
Dit kan vooral 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.
NULL-waarden
Het percentage (% ) wildcard komt overeen met alles - bijna. Een ding dat niet overeenkomt is NULL .
SELECT * FROM Owners
WHERE Email LIKE '%';Resultaat:
+---------+-----------+----------+----------------+--------------------+ | 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] | +---------+-----------+----------+----------------+--------------------+
In onze tabel zijn er twee rijen met NULL in de Email kolom, maar die worden hier niet geretourneerd.
Prestaties
Zoekopdrachten die de LIKE . bevatten operator kan veel langzamer lopen dan andere zoekopdrachten, en u moet waarschijnlijk het gebruik van de LIKE . vermijden operator, tenzij u het echt nodig hebt. De % . gebruiken operator als voorvoegsel kan bijzonder traag zijn.
Dat wil niet zeggen dat je het helemaal niet moet gebruiken. De LIKE operator is een integraal onderdeel van SQL en u zult veel scenario's tegenkomen waarin dit de enige optie is (of op zijn minst de beste optie).
De NOT LIKE Operator
Je kunt ook NOT LIKE . gebruiken om te testen of een string al dan niet niet overeenkomen met een patroon.