W MariaDB NOT LIKE operator jest używany do sprawdzenia, czy łańcuch nie dopasuj wzór. Zwraca odwrotność LIKE operator. To to samo, co zastosowanie NOT operator przeciwko całemu LIKE wyrażenie.
Wzorzec może zawierać zwykłe znaki, a także % i _ znaki wieloznaczne.
Te symbole wieloznaczne są wyjaśnione w poniższej tabeli.
| Wildcard | Opis |
|---|---|
% | Dopasowuje dowolny ciąg składający się z zera lub większej liczby znaków. Może być używany jako prefiks lub sufiks, a także może być używany w środku ciągu. |
_ | Dopasowuje dowolny pojedynczy znak. |
Składnia
Składnia wygląda tak:
expr NOT LIKE pat [ESCAPE 'escape_char']Przykład
Załóżmy, że mamy następującą tabelę:
SELECT * FROM Pets;Wynik:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Oto przykład użycia NOT LIKE na tej tabeli:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Wynik:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
W tym przykładzie użyłem NOT LIKE w połączeniu z % operator wieloznaczny do zwracania zwierząt, których imię nie zacznij od litery F .
Jest to odwrotny zestaw wyników, który otrzymalibyśmy, gdybyśmy po prostu użyli LIKE . W takim przypadku otrzymalibyśmy tylko wyniki, w których imię zwierzaka zaczyna się od litery F .
Wrażliwość na wielkość liter
NOT LIKE wykonuje dopasowania podciągów bez uwzględniania wielkości liter, jeśli sortowanie wyrażenia i wzorca nie uwzględnia wielkości liter.
Dlatego możemy zmienić poprzedni przykład, aby używał małych liter f i nadal uzyskaj ten sam wynik:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%';Wynik:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Możemy jednak wymusić dopasowanie uwzględniające wielkość liter, używając COLLATE klauzula z zestawieniem binarnym. Alternatywnie możesz użyć CAST() przekształcenie go w ciąg binarny.
Przykład:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%' COLLATE utf8_bin;Wynik:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Tym razem zwrócono cały stół. Dzieje się tak, ponieważ nic nie pasuje do małej litery f .
Ale jeśli zmienimy go na wielkie F :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Wynik:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Zgodnie z oczekiwaniami otrzymujemy pięć meczów. Wiersze, w których imię zwierzaka zaczyna się od F są wykluczone.
Argumenty liczbowe
Argumenty numeryczne są przekształcane w ciągi binarne.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Wynik:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Daty
Oto przykład daty:
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Wynik:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
Możesz także użyć NOT LIKE operator względem wyniku funkcji dat, takich jak DAYNAME() , MONTHNAME() itp.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Wynik:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
_ Operator wieloznaczny
Podkreślenie (_ ) operator wieloznaczny pasuje do dowolnego pojedynczego znaku.
Przykład:
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Wynik:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
W tym przypadku zwróciliśmy imiona zwierząt, w których drugi znak nie e .
Postać ucieczki
Czasami możesz znaleźć się w sytuacji, w której musisz szukać podkreślenia lub znaku procentowego. W takich przypadkach możesz użyć odwrotnego ukośnika (\ ), aby uciec od tych znaków. Zapobiegnie to interpretowaniu ich jako symboli wieloznacznych.
Załóżmy, że mamy następującą tabelę:
SELECT * FROM Owners;Wynik:
+---------+-----------+----------+----------------+--------------------+ | 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] | +---------+-----------+----------+----------------+--------------------+
Zwróć uwagę, że właściciel 2 (Bart) ma adres e-mail zawierający podkreślenie.
Oto przykład tego, co się dzieje, gdy nie uciec od podkreślenia:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b_%';Wynik:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
W tym przypadku zwrócił tylko dwa wiersze. Wykluczyło to dwa wiersze, w których adres e-mail zaczyna się od b i następuje jeden inny znak, a następnie dowolna liczba znaków. Wykluczył również wiersze z null adres e-mail.
Ponieważ jednak nie uniknęliśmy podkreślenia, nie miało znaczenia, jaki był drugi znak – pasował do dowolnego postać. To, że pierwszy wiersz zawiera podkreślenie drugiego znaku, to tylko zbieg okoliczności. Pasowałby nawet, gdyby był czymś innym.
Ale co, gdybyśmy chcieli dopasować tylko te adresy e-mail, które mają podkreślenie jako drugi znak?
W tym miejscu pojawia się postać ucieczki.
SELECT * FROM Owners
WHERE Email NOT LIKE 'b\_%';Wynik:
+---------+-----------+----------+----------------+-------------------+ | 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] | +---------+-----------+----------+----------------+-------------------+
Widzimy, że Burt został dodany do wyników.
Zmiana postaci ucieczki
Istnieje możliwość zmiany charakteru ucieczki. Możesz to zrobić za pomocą ESCAPE argument.
Przykład:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b*_%' ESCAPE '*';Wynik:
+---------+-----------+----------+----------------+-------------------+ | 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] | +---------+-----------+----------+----------------+-------------------+
W tym przypadku przypisałem gwiazdkę (* ) jako znak ucieczki.
Może to być przydatne, gdy musisz użyć odwrotnego ukośnika do innych celów, takich jak kodowanie znaków specjalnych. W takich przypadkach może się okazać, że będziesz musiał „podwójnie uciec” tym postaciom, co może być mylące. Dlatego zmiana znaku ucieczki może pomóc w takich sytuacjach.
