Hur LIKE-operatören fungerar i MySQL

I MySQL, LIKE operatorn utför mönstermatchning med ett SQL-mönster.

Om strängen matchar mönstret som tillhandahålls blir resultatet 1 , annars är det 0 .

Mönstret behöver inte nödvändigtvis vara en bokstavlig sträng. Denna funktion kan användas med stränguttryck och tabellkolumner.

Syntax

Syntaxen ser ut så här:

expr LIKE pat [ESCAPE 'escape_char']

Där expr är inmatningssträngen och pat är mönstret som du testar strängen mot.

Den valfria ESCAPE sats låter dig ange ett escape-tecken. Standardtecknet för escape är \ , så du kan utelämna den här klausulen om du inte behöver ändra den.

Exempel 1 – Grundläggande användning

Här är ett exempel på hur du använder den här operatorn i en SELECT uttalande:

SELECT 'Charlie' LIKE 'Char%';

Resultat:

+------------------------+
| 'Charlie' LIKE 'Char%' |
+------------------------+
|                      1 |
+------------------------+

I det här fallet är returvärdet 1 vilket betyder att inmatningssträngen matchade mönstret. Speciellt specificerade vi att inmatningssträngen skulle börja med Char och avsluta med vad som helst. % tecken matchar valfritt antal tecken (inklusive noll tecken).

Här är vad som händer om vi tappar % :

SELECT 'Charlie' LIKE 'Char';

Resultat:

+-----------------------+
| 'Charlie' LIKE 'Char' |
+-----------------------+
|                     0 |
+-----------------------+

Returresultatet är 0 vilket betyder ingen match. Detta beror på att vi inte använde ett jokertecken för att ange några andra tecken.

Exempel 2 – _ Jokertecken

Vi har också möjlighet att använda _ jokertecken för att endast ange ett enda tecken. Här är ett exempel:

SELECT 'Charlie' LIKE 'Ch_rlie';

Resultat:

+--------------------------+
| 'Charlie' LIKE 'Ch_rlie' |
+--------------------------+
|                        1 |
+--------------------------+

De två jokertecken kan kombineras i ett mönster om det behövs:

SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%' AS 'Result';

Resultat:

+--------+
| Result |
+--------+
|      1 |
+--------+

Här är några fler:

SELECT 
  'Charlie likes donuts' LIKE 'Ch_rlie%donuts' AS 'Result 1',
  'Charlie likes donuts' LIKE 'Ch_rlie%nuts' AS 'Result 2',
  'Charlie likes donuts' LIKE 'Ch%rlie %likes %' AS 'Result 3',
  'Charlie likes donuts' LIKE '% likes %' AS 'Result 4';

Resultat:

+----------+----------+----------+----------+
| Result 1 | Result 2 | Result 3 | Result 4 |
+----------+----------+----------+----------+
|        1 |        1 |        1 |        1 |
+----------+----------+----------+----------+

Låt oss göra några ändringar i det exemplet så att vi kan se några exempel på när de inte matchar:

SELECT 
  'Charlie likes donuts' LIKE 'Ch%rlie_donuts' AS 'Result 1',
  'Charlie likes donuts' LIKE 'Charlie_nuts' AS 'Result 2',
  'Charlie likes donuts' LIKE 'Charlie _likes donuts' AS 'Result 3',
  'Charlie likes donuts' LIKE '_ likes _' AS 'Result 4';

Resultat:

+----------+----------+----------+----------+
| Result 1 | Result 2 | Result 3 | Result 4 |
+----------+----------+----------+----------+
|        0 |        0 |        0 |        0 |
+----------+----------+----------+----------+

Exempel 3 – Ett databasexempel

LIKE operatorn används ofta inom en WHERE sats av en SELECT uttalande när du frågar efter en databas. När den används på det här sättet, begränsar den resultaten till endast de poster som matchar, men vi ser de faktiska resultaten (inte bara en 1 eller 0 ).

Här är ett exempel på hur vi kan använda den här operatorn i en databasfråga:

SELECT ArtistId, ArtistName
FROM Artists
WHERE ArtistName LIKE 'B%';

Resultat:

+----------+----------------+
| ArtistId | ArtistName     |
+----------+----------------+
|        4 | Buddy Rich     |
|       11 | Black Sabbath  |
|       15 | Birds of Tokyo |
|       16 | Bodyjar        |
+----------+----------------+

I det här fallet var det en enkel fråga som returnerar alla artister vars namn börjar med bokstaven B .

Här är hela listan över artister i tabellen:

SELECT ArtistId, ArtistName
FROM Artists;

Resultat:

+----------+------------------------+
| ArtistId | ArtistName             |
+----------+------------------------+
|        1 | Iron Maiden            |
|        2 | AC/DC                  |
|        3 | Allan Holdsworth       |
|        4 | Buddy Rich             |
|        5 | Devin Townsend         |
|        6 | Jim Reeves             |
|        7 | Tom Jones              |
|        8 | Maroon 5               |
|        9 | The Script             |
|       10 | Lit                    |
|       11 | Black Sabbath          |
|       12 | Michael Learns to Rock |
|       13 | Carabao                |
|       14 | Karnivool              |
|       15 | Birds of Tokyo         |
|       16 | Bodyjar                |
+----------+------------------------+

Exempel 4 – Att fly med bakåtstrecket

Vad händer om ett av jokertecken finns i din inmatningssträng och du behöver göra en matchning mot den? Du kan undvika det med omvänt snedstreck (\ ). Här är ett exempel på en sådan sökning med och utan escape-tecknet:

SELECT 
  'usr_123' LIKE 'usr_123' AS 'Without escape',
  'usr_123' LIKE 'usr\_123' AS 'With escape';

Resultat:

+----------------+-------------+
| Without escape | With escape |
+----------------+-------------+
|              1 |           1 |
+----------------+-------------+

I det här fallet matchade de båda, men av olika anledningar. Den första raden matchade eftersom jokertecknet angav att vilket tecken som helst kommer att matcha. Den andra raden matchade också, men bara för att inmatningssträngen råkade ha ett understreck på rätt plats.

Låt oss ändra inmatningssträngen något så att vi får ett annat resultat:

SELECT 
  'usr+123' LIKE 'usr_123' AS 'Without escape',
  'usr+123' LIKE 'usr\_123' AS 'With escape';

Resultat:

+----------------+-------------+
| Without escape | With escape |
+----------------+-------------+
|              1 |           0 |
+----------------+-------------+

Den oförkomna versionen returnerade positivt, eftersom jokertecknet innebar att vi kunde ha vilken karaktär som helst på den platsen. Den undanröjda versionen angav uttryckligen att endast understrecket (_ ) kommer att matcha. Inmatningssträngen hade inget understreck på den platsen och resultatet blev därför negativt.

Exempel 5 – ESCAPE Klausul

Du kan också använda ESCAPE klausul för att specificera din egen anpassade escape-karaktär. Här är ett exempel:

SELECT 
  'usr_123' LIKE 'usr|_123' ESCAPE '|' AS 'String 1',
  'usr+123' LIKE 'usr|_123' ESCAPE '|' AS 'String 2';

Resultat:

+----------+----------+
| String 1 | String 2 |
+----------+----------+
|        1 |        0 |
+----------+----------+

Exempel 6 – Numeriska uttryck

MySQL-implementeringen av LIKE operatorn tillåter att numeriska uttryck används. Här är ett exempel:

SELECT 
  1234 LIKE '12%',
  1234 LIKE '12_';

Resultat:

+-----------------+-----------------+
| 1234 LIKE '12%' | 1234 LIKE '12_' |
+-----------------+-----------------+
|               1 |               0 |
+-----------------+-----------------+