V MariaDB, NOT LIKE Operátor se používá k testování, zda řetězec nedělá odpovídat vzoru. Vrací inverzní hodnotu k LIKE operátor. Je to stejné jako použití NOT operátor proti celému LIKE výraz.
Vzor může obsahovat běžné znaky a také % a _ zástupné znaky.
Tyto zástupné znaky jsou vysvětleny v následující tabulce.
| Zástupný znak | Popis |
|---|---|
% | Odpovídá libovolnému řetězci nula nebo více znaků. Může být použit buď jako předpona, nebo jako přípona, a také může být použit uprostřed řetězce. |
_ | Odpovídá libovolnému jednotlivému znaku. |
Syntaxe
Syntaxe vypadá takto:
expr NOT LIKE pat [ESCAPE 'escape_char']Příklad
Předpokládejme, že máme následující tabulku:
SELECT * FROM Pets;Výsledek:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Zde je příklad použití NOT LIKE proti této tabulce:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Výsledek:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
V tomto příkladu jsem použil NOT LIKE ve spojení s % zástupný operátor pro návrat domácích mazlíčků, jejichž jméno není začíná písmenem F .
Toto je opačný soubor výsledků, jaký bychom dostali, kdybychom použili pouze LIKE . V takovém případě bychom získali pouze výsledky, kde jméno zvířete začíná písmenem F .
Rozlišovat malá a velká písmena
NOT LIKE provádí shody podřetězců bez rozlišení malých a velkých písmen, pokud řazení výrazu a vzoru nerozlišuje malá a velká písmena.
Proto můžeme změnit předchozí příklad tak, aby používal malé f a stále získáte stejný výsledek:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%';Výsledek:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Můžeme však vynutit shodu rozlišující malá a velká písmena pomocí COLLATE klauzule s binárním řazením. Případně můžete použít CAST() vynutit jej na binární řetězec.
Příklad:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%' COLLATE utf8_bin;Výsledek:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Tentokrát byl vrácen celý stůl. Je to proto, že nic neodpovídalo malým písmenům f .
Ale když to změníme na velké F :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Výsledek:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Máme za sebou pět zápasů, jak se očekávalo. Řádky, kde jméno mazlíčka začíná F jsou vyloučeny.
Číselné argumenty
Číselné argumenty jsou vynuceny na binární řetězce.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Výsledek:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Data
Zde je příklad data:
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Výsledek:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
Můžete také použít NOT LIKE operátor proti výsledku funkcí data, jako je DAYNAME() , MONTHNAME() , atd.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Výsledek:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
_ Operátor zástupných znaků
Podtržítko (_ ) zástupný operátor odpovídá libovolnému jednotlivému znaku.
Příklad:
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Výsledek:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
V tomto případě jsme vrátili jména zvířat, kde druhý znak není e .
Únikový znak
Někdy se můžete dostat do situace, kdy potřebujete hledat podtržítko nebo znak procenta. V takových případech můžete použít zpětné lomítko (\ ), abyste těmto znakům unikli. To zabrání tomu, aby byly interpretovány jako zástupné znaky.
Předpokládejme, že máme následující tabulku:
SELECT * FROM Owners;Výsledek:
+---------+-----------+----------+----------------+--------------------+ | 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] | +---------+-----------+----------+----------------+--------------------+
Všimněte si, že vlastník 2 (Bart) má e-mailovou adresu, která obsahuje podtržítko.
Zde je příklad toho, co se stane, když neděláme uniknout podtržítku:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b_%';Výsledek:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
V tomto případě to vrátilo jen dva řádky. Vyloučil dva řádky, kde e-mailová adresa začíná b , a za ním následuje jeden další znak a poté libovolný počet znaků. Vyloučil také řádky s null e-mailovou adresu.
Protože jsme však neunikli podtržítku, nezáleželo na tom, jaký byl druhý znak – odpovídalo jakémukoli charakter. To, že první řádek obsahuje podtržítko u druhého znaku, je jen náhoda. Odpovídalo by to, i kdyby to bylo něco jiného.
Ale co kdybychom chtěli porovnat pouze ty e-mailové adresy, které mají skutečný podtržítko jako druhý znak?
Zde přichází na řadu úniková postava.
SELECT * FROM Owners
WHERE Email NOT LIKE 'b\_%';Výsledek:
+---------+-----------+----------+----------------+-------------------+ | 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] | +---------+-----------+----------+----------------+-------------------+
Vidíme, že Burt byl přidán do výsledků.
Změna únikového znaku
Je možné změnit únikový znak. Můžete to udělat pomocí ESCAPE argument.
Příklad:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b*_%' ESCAPE '*';Výsledek:
+---------+-----------+----------+----------------+-------------------+ | 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] | +---------+-----------+----------+----------------+-------------------+
V tomto případě jsem přiřadil hvězdičku (* ) jako znak escape.
To může být užitečné, když potřebujete použít zpětné lomítko pro jiné účely, jako je kódování speciálních znaků. V takových případech se může stát, že budete muset těmto postavám „dvojitě uniknout“, což by mohlo být matoucí. Změna únikového znaku proto může v takových situacích pomoci.