Jak działa operator LIKE w MariaDB

W MariaDB element LIKE operator pozwala na dopasowanie wzorca. Określa, czy określony ciąg znaków pasuje do określonego wzorca. Zwraca albo 1 (PRAWDA) lub 0 (FAŁSZYWY).

Wzorzec może zawierać zwykłe znaki, a także % i _ znaki wieloznaczne.

Te symbole wieloznaczne wyjaśniono 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 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 pokazujący, jak LIKE operator pracuje.

SELECT *
FROM Pets
WHERE PetName LIKE 'F%';

Wynik:

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

W tym przykładzie użyłem LIKE operator w połączeniu z % operator wieloznaczny do zwracania zwierząt, których imię zaczyna się na literę F .

Wrażliwość na wielkość liter

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 LIKE 'f%';

Wynik:

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

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 LIKE 'f%' COLLATE utf8_bin;

Wynik:

Empty set (0.000 sec)

Żadne wyniki nie są zwracane.

Ale jeśli zmienimy go na wielkie F :

SELECT *
FROM Pets
WHERE PetName 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 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

Zgodnie z oczekiwaniami otrzymujemy trzy dopasowania.

Argumenty liczbowe

Argumenty numeryczne są przekształcane w ciągi binarne.

SELECT * 
FROM Pets 
WHERE PetId LIKE 7;

Wynik:

+-------+-----------+---------+---------+------+
| PetId | PetTypeId | OwnerId | PetName | DOB  |
+-------+-----------+---------+---------+------+
|     7 |         3 |       2 | Bark    | NULL |
+-------+-----------+---------+---------+------+

Daty

Oto przykład pasujący do roku od daty:

SELECT * 
FROM Pets 
WHERE DOB LIKE '2020%';

Wynik:

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

Możesz także użyć LIKE operator względem wyniku funkcji dat, takich jak DAYNAME() , MONTHNAME() itp.

SELECT * 
FROM Pets 
WHERE MONTHNAME(DOB) LIKE 'Nov%';

Wynik:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
+-------+-----------+---------+---------+------------+

`_` Operator wieloznaczny

Podkreślenie (_ ) operator wieloznaczny pasuje do dowolnego pojedynczego znaku.

Przykład:

SELECT *
FROM Pets
WHERE PetName LIKE '_e%';

Wynik:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     8 |         2 |       4 | Meow    | NULL       |
+-------+-----------+---------+---------+------------+

W tym przypadku dopasowaliśmy imiona zwierząt, w których drugim znakiem jest 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 LIKE 'b_%';

Wynik:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
|       6 | Burt      | Tyson    | (309) 565-0112 | [email protected]   |
+---------+-----------+----------+----------------+--------------------+

W tym przypadku pasował do dwóch rzędów. W tym przypadku 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 LIKE 'b\_%';

Wynik:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
+---------+-----------+----------+----------------+--------------------+

Teraz otrzymujemy tylko jeden wiersz – wiersz zawierający podkreślenie jako drugi znak.

Zmiana postaci ucieczki

Istnieje możliwość zmiany charakteru ucieczki. Możesz to zrobić za pomocą ESCAPE argument.

Przykład:

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

Wynik:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
+---------+-----------+----------+----------------+--------------------+

W tym przypadku przypisałem gwiazdkę (* ) jako znak ucieczki.

Może to być szczególnie 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.

Wartości NULL

Procent (% ) symbol wieloznaczny pasuje do wszystkiego – prawie. Jedna rzecz, która nie pasuje, to NULL .

SELECT * FROM Owners
WHERE Email LIKE '%';

Wynik:

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

W naszej tabeli znajdują się dwa wiersze z NULL w Email kolumna, ale te nie są tutaj zwracane.

Wydajność

Zapytania zawierające LIKE operator może działać znacznie wolniej niż inne zapytania i prawdopodobnie powinieneś unikać używania LIKE operatora, chyba że naprawdę tego potrzebujesz. Korzystanie z % operator jako prefiks może być szczególnie powolny.

Nie oznacza to, że w ogóle nie powinieneś go używać. LIKE Operator jest integralną częścią SQL i napotkasz wiele scenariuszy, w których będzie to jedyna opcja (lub przynajmniej najlepsza opcja).