I MariaDB er LIKE operatør giver dig mulighed for at lave mønstertilpasning. Det bestemmer, om en specifik tegnstreng matcher et specificeret mønster. Det returnerer enten 1 (TRUE) eller 0 (FALSK).
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 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 for at demonstrere, hvordan LIKE operatør arbejder.
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 dette eksempel brugte jeg LIKE operator sammen med % wildcard-operatør for at returnere kæledyr, hvis navn starter med bogstavet F .
Skrivar og bogstaver
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 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 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 LIKE 'f%' COLLATE utf8_bin;Resultat:
Empty set (0.000 sec)
Ingen resultater returneres.
Men hvis vi ændrer det til et stort 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 kampe, som forventet.
Numeriske argumenter
Numeriske argumenter tvinges til binære strenge.
SELECT *
FROM Pets
WHERE PetId LIKE 7;Resultat:
+-------+-----------+---------+---------+------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------+ | 7 | 3 | 2 | Bark | NULL | +-------+-----------+---------+---------+------+
Datoer
Her er et eksempel, der matcher året fra en dato:
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 også bruge LIKE operator mod resultatet af datofunktioner, såsom DAYNAME() , MONTHNAME() osv.
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 | +-------+-----------+---------+---------+------------+
__ Wildcard-operatør
Understregningen (__ ) wildcard-operator matcher ethvert enkelt tegn.
Eksempel:
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 dette tilfælde matchede vi kæledyrsnavne, hvor det andet tegn er 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 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 dette tilfælde matchede det to rækker. I dette tilfælde var det lige meget, hvad det andet tegn var - det matchede hvilket som helst 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 LIKE 'b\_%';Resultat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Nu får vi kun én række – den række, der indeholder understregningen som det andet tegn.
Ændring af Escape-karakteren
Det er muligt at ændre flugtkarakteren. Du kan gøre dette med ESCAPE argument.
Eksempel:
SELECT * FROM Owners
WHERE Email LIKE 'b*_%' ESCAPE '*';Resultat:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
I dette tilfælde tildelte jeg stjernen (* ) som escape-tegn.
Dette kan især 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 opleve, at du skal "dobbelt-escape" disse karakterer, hvilket kan blive forvirrende. Ændring af flugtkarakteren kan derfor hjælpe i sådanne situationer.
NULL-værdier
Procentdelen (% ) jokertegn matcher alt – næsten. En ting, den ikke matcher, er 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 vores tabel er der to rækker med NULL i E-mail kolonne, men de returneres ikke her.
Ydeevne
Forespørgsler, der indeholder LIKE operatør kan køre meget langsommere end andre forespørgsler, og du bør nok undgå at bruge LIKE operatør, medmindre du virkelig har brug for det. Brug af % operator som præfiks kan være særlig langsom.
Det betyder ikke, at du slet ikke skal bruge det. LIKE operatør er en integreret del af SQL, og du vil støde på mange scenarier, hvor det vil være den eneste mulighed (eller i det mindste den bedste mulighed).
Koden IKKE LIKE Operatør
Du kan også bruge IKKE LIKE for at teste om en streng ikke gør det matche et mønster.