В MariaDB, NOT LIKE операторът се използва за проверка дали низ не съвпада с модел. Връща обратното на LIKE оператор. Това е същото като прилагането на NOT оператор срещу целия LIKE изразяване.
Моделът може да включва обикновени знаци, както и % и _ заместващи знаци.
Тези заместващи знаци са обяснени в следващата таблица.
| Заместващ знак | Описание |
|---|---|
% | Съвпада с всеки низ от нула или повече знака. Може да се използва като префикс или суфикс и може да се използва и в средата на низ. |
_ | Съвпада на всеки единичен знак. |
Синтаксис
Синтаксисът е така:
expr NOT LIKE pat [ESCAPE 'escape_char']Пример
Да предположим, че имаме следната таблица:
SELECT * FROM Pets;Резултат:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Ето пример за използване на NOT LIKE срещу тази таблица:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Резултат:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
В този пример използвах NOT LIKE във връзка с % оператор със заместващ знак, за да върне домашни любимци, чието име не започва с буквата F .
Това е обратният набор от резултати, който бихме получили, ако просто използвахме LIKE . В този случай ще получим резултати само там, където името на домашния любимец започва с буквата F .
Чувствителност на регистрите
NOT LIKE изпълнява съвпадения на поднизове, независимо от главните букви, ако съпоставянето за израза и шаблона не е чувствително.
Следователно можем да променим предишния пример, за да използваме малки букви f , и пак получавате същия резултат:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%';Резултат:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Въпреки това, ние можем да принудим съвпадение, чувствително към главни букви, като използваме COLLATE клауза с двоично съпоставяне. Като алтернатива можете да използвате CAST() за да го принудите към двоичен низ.
Пример:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%' COLLATE utf8_bin;Резултат:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Този път цялата маса беше върната. Това е така, защото нищо не съответства на малкия регистър f .
Но ако го променим на главни букви F :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Резултат:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Получаваме пет мача, както се очакваше. Редовете, където името на домашния любимец започва с F са изключени.
Числови аргументи
Числовите аргументи са принудени към двоични низове.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Резултат:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Дати
Ето пример за дата:
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Резултат:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
Можете също да използвате NOT LIKE оператор срещу резултата от функции за дата, като DAYNAME() , MONTHNAME() и др.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Резултат:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
_ Оператор за заместващи знаци
Долната черта (_ ) операторът за заместващ знак съответства на всеки единичен знак.
Пример:
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Резултат:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
В този случай върнахме имена на домашни любимци, където вторият знак е не e .
Характерът за бягство
Понякога може да се окажете в ситуацията, в която трябва да търсите долна черта или знак за процент. В такива случаи можете да използвате обратна наклонена черта (\ ), за да избягате от тези знаци. Това ще предотврати тяхното интерпретиране като заместващи знаци.
Да предположим, че имаме следната таблица:
SELECT * FROM Owners;Резултат:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 1 | Homer | Connery | (308) 555-0100 | example@sqldat.com | | 2 | Bart | Pitt | (231) 465-3497 | example@sqldat.com | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | example@sqldat.com | | 6 | Burt | Tyson | (309) 565-0112 | example@sqldat.com | +---------+-----------+----------+----------------+--------------------+
Забележете, че собственик 2 (Барт) има имейл адрес, който съдържа долна черта.
Ето пример за това какво се случва, когато не избягване на долна черта:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b_%';Резултат:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | example@sqldat.com | | 5 | Woody | Eastwood | (308) 555-0112 | example@sqldat.com | +---------+-----------+----------+----------------+-------------------+
В този случай той върна само два реда. Той изключва двата реда, където имейл адресът започва с b , и е последван от още един знак и след това произволен брой знаци. Той също така изключва редовете с null имейл адрес.
Въпреки това, тъй като не избягахме от долната черта, нямаше значение какъв е вторият знак – отговаряше на всяко характер. Фактът, че първият ред съдържа долна черта за втория знак, е просто съвпадение. Щеше да съвпадне дори и да беше нещо друго.
Но какво, ако искаме да съпоставим само тези имейл адреси, които имат действително долно черта като втори знак?
Тук идва символът за бягство.
SELECT * FROM Owners
WHERE Email NOT LIKE 'b\_%';Резултат:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | example@sqldat.com | | 5 | Woody | Eastwood | (308) 555-0112 | example@sqldat.com | | 6 | Burt | Tyson | (309) 565-0112 | example@sqldat.com | +---------+-----------+----------+----------------+-------------------+
Можем да видим, че Бърт е добавен към резултатите.
Промяна на изходния символ
Възможно е да промените escape символа. Можете да направите това с ESCAPE аргумент.
Пример:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b*_%' ESCAPE '*';Резултат:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | example@sqldat.com | | 5 | Woody | Eastwood | (308) 555-0112 | example@sqldat.com | | 6 | Burt | Tyson | (309) 565-0112 | example@sqldat.com | +---------+-----------+----------+----------------+-------------------+
В този случай присвоих звездичката (* ) като escape-символ.
Това може да бъде удобно, когато трябва да използвате обратната наклонена черта за други цели, като например кодиране на специални символи. В такива случаи може да се наложи да „избягате двойно“ от тези знаци, което може да стане объркващо. Следователно промяната на escape-символа може да помогне в такива ситуации.
