MariaDB
 sql >> база данни >  >> RDS >> MariaDB

Как NOT LIKE работи в MariaDB

В 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 | [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]   |
+---------+-----------+----------+----------------+--------------------+

Забележете, че собственик 2 (Барт) има имейл адрес, който съдържа долна черта.

Ето пример за това какво се случва, когато не избягване на долна черта:

SELECT * FROM Owners
WHERE Email NOT LIKE 'b_%';

Резултат:

+---------+-----------+----------+----------------+-------------------+
| OwnerId | FirstName | LastName | Phone          | Email             |
+---------+-----------+----------+----------------+-------------------+
|       1 | Homer     | Connery  | (308) 555-0100 | [email protected] |
|       5 | Woody     | Eastwood | (308) 555-0112 | [email protected] |
+---------+-----------+----------+----------------+-------------------+

В този случай той върна само два реда. Той изключва двата реда, където имейл адресът започва с b , и е последван от още един знак и след това произволен брой знаци. Той също така изключва редовете с null имейл адрес.

Въпреки това, тъй като не избягахме от долната черта, нямаше значение какъв е вторият знак – отговаряше на всяко характер. Фактът, че първият ред съдържа долна черта за втория знак, е просто съвпадение. Щеше да съвпадне дори и да беше нещо друго.

Но какво, ако искаме да съпоставим само тези имейл адреси, които имат действително долно черта като втори знак?

Тук идва символът за бягство.

SELECT * FROM Owners
WHERE Email NOT LIKE 'b\_%';

Резултат:

+---------+-----------+----------+----------------+-------------------+
| 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]  |
+---------+-----------+----------+----------------+-------------------+

Можем да видим, че Бърт е добавен към резултатите.

Промяна на изходния символ

Възможно е да промените escape символа. Можете да направите това с ESCAPE аргумент.

Пример:

SELECT * FROM Owners
WHERE Email NOT LIKE 'b*_%' ESCAPE '*';

Резултат:

+---------+-----------+----------+----------------+-------------------+
| 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]  |
+---------+-----------+----------+----------------+-------------------+

В този случай присвоих звездичката (* ) като escape-символ.

Това може да бъде удобно, когато трябва да използвате обратната наклонена черта за други цели, като например кодиране на специални символи. В такива случаи може да се наложи да „избягате двойно“ от тези знаци, което може да стане объркващо. Следователно промяната на escape-символа може да помогне в такива ситуации.


  1. Database
  2.   
  3. Mysql
  4.   
  5. Oracle
  6.   
  7. Sqlserver
  8.   
  9. PostgreSQL
  10.   
  11. Access
  12.   
  13. SQLite
  14.   
  15. MariaDB
  1. Първи стъпки с MariaDB с помощта на Docker, Java Spring и JDBC

  2. Съображения относно криптирането на данни в покой за MariaDB

  3. Обявяване на ClusterControl 1.7.4:Репликация от клъстер към клъстер – Крайно възстановяване при бедствия

  4. Как DATEDIFF() работи в MariaDB

  5. Как работи DAYOFWEEK() в MariaDB