I MariaDB er NOT LIKE operator bruges til at teste om en streng ikke gør det matche et mønster. Det returnerer det omvendte af LIKE operatør. Det er det samme som at anvende NOT operator mod hele LIKE udtryk.
Et mønster kan indeholde almindelige tegn såvel som % og __ jokertegn.
Disse jokertegn er forklaret i følgende tabel.
| Jokertegn | Beskrivelse |
|---|---|
% | Matcher enhver streng med nul eller flere tegn. Det kan bruges som enten et præfiks eller et suffiks, og det kan også bruges i midten af en streng. |
| Matcher ethvert enkelt tegn. |
Syntaks
Syntaksen ser sådan ud:
expr NOT LIKE pat [ESCAPE 'escape_char']Eksempel
Antag, at vi har følgende tabel:
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 | +-------+-----------+---------+---------+------------+
Her er et eksempel på brug af IKKE LIKE mod denne tabel:
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 dette eksempel brugte jeg NOT LIKE i forbindelse med % wildcard-operatør for at returnere kæledyr, hvis navn ikke gør start med bogstavet F .
Dette er det modsatte resultatsæt, vi ville have fået, hvis vi bare havde brugt LIKE . I så fald vil vi kun få resultater, hvor kæledyrets navn starter med bogstavet F .
Skrivar og bogstaver
IKKE LIKE udfører substring-matches, der ikke er store og små, hvis sorteringen for udtrykket og mønsteret er ufølsom.
Derfor kan vi ændre det forrige eksempel til at bruge et lille f , og stadig få det samme 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 dog fremtvinge et match, der skelner mellem store og små bogstaver, ved at bruge COLLATE klausul med en binær sammenstilling. Alternativt kan du bruge CAST() at tvinge den til en binær streng.
Eksempel:
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 | +-------+-----------+---------+---------+------------+
Denne gang blev hele bordet returneret. Dette skyldes, at intet matchede det lille f .
Men hvis vi ændrer det til et stort 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 kampe, som forventet. Rækkerne, hvor kæledyrsnavnet starter med F er udelukket.
Numeriske argumenter
Numeriske argumenter tvinges til binære strenge.
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 | +-------+-----------+---------+---------+------------+
Datoer
Her er et datoeksempel:
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 også bruge koden IKKE LIKE operator mod resultatet af datofunktioner, såsom DAYNAME() , MONTHNAME() osv.
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 | +-------+-----------+---------+---------+------------+
__ Wildcard-operatør
Understregningen (__ ) wildcard-operator matcher ethvert enkelt tegn.
Eksempel:
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 dette tilfælde returnerede vi kæledyrsnavne, hvor det andet tegn er ikke en e .
Escape-karakteren
Nogle gange kan du finde dig selv i den situation, hvor du skal søge efter en understregning eller et procenttegn. I sådanne tilfælde kan du bruge en omvendt skråstreg (\ ) for at undslippe disse tegn. Dette forhindrer dem i at blive fortolket som jokertegn.
Antag, at vi har følgende tabel:
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] | +---------+-----------+----------+----------------+--------------------+
Bemærk, at Ejer 2 (Bart) har en e-mailadresse, der indeholder en understregning.
Her er et eksempel på, hvad der sker, når vi ikke undslippe en understregning:
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 dette tilfælde returnerede den kun to rækker. Den udelukkede de to rækker, hvor e-mailadressen starter med en b , og efterfølges af et andet tegn og derefter et vilkårligt antal tegn. Det ekskluderede også rækkerne med en null e-mailadresse.
Men fordi vi ikke undslap understregningen, var det lige meget, hvad den anden karakter var - den matchede enhver Karakter. At den første række indeholder en understregning for den anden karakter er blot en tilfældighed. Det ville have matchet, selvom det var noget andet.
Men hvad nu hvis vi kun ville matche de e-mailadresser, der har en faktisk understregning som deres andet tegn?
Det er her flugtkarakteren kommer ind.
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, at Burt er blevet tilføjet til resultaterne.
Ændring af Escape-karakteren
Det er muligt at ændre flugtkarakteren. Du kan gøre dette med ESCAPE argument.
Eksempel:
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 dette tilfælde tildelte jeg stjernen (* ) som escape-tegn.
Dette kan være praktisk, når du skal bruge omvendt skråstreg til andre formål, såsom indkodning af specialtegn. I sådanne tilfælde kan du finde på at skulle "dobbelt-escape" disse karakterer, hvilket kan blive forvirrende. Ændring af flugtkarakteren kan derfor hjælpe i sådanne situationer.