In MySQL is de LIKE operator voert patroonovereenkomst uit met behulp van een SQL-patroon.
Als de tekenreeks overeenkomt met het opgegeven patroon, is het resultaat 1 , anders is het 0 .
Het patroon hoeft niet per se een letterlijke tekenreeks te zijn. Deze functie kan worden gebruikt met tekenreeksuitdrukkingen en tabelkolommen.
Syntaxis
De syntaxis gaat als volgt:
expr LIKE pat [ESCAPE 'escape_char']
Waar expr is de invoerreeks en pat is het patroon waarvoor u de snaar test.
De optionele ESCAPE clausule kunt u een escape-teken specificeren. Het standaard escape-teken is \ , dus u kunt deze clausule weglaten als u deze niet hoeft te wijzigen.
Voorbeeld 1 – Basisgebruik
Hier is een voorbeeld van het gebruik van deze operator in een SELECT verklaring:
SELECT 'Charlie' LIKE 'Char%';
Resultaat:
+------------------------+ | 'Charlie' LIKE 'Char%' | +------------------------+ | 1 | +------------------------+
In dit geval is de retourwaarde 1 wat betekent dat de invoerreeks overeenkomt met het patroon. In het bijzonder hebben we gespecificeerd dat de invoerreeks moet beginnen met Char en eindigen met iets. De % teken komt overeen met een willekeurig aantal tekens (inclusief nul tekens).
Dit is wat er gebeurt als we de % . laten vallen :
SELECT 'Charlie' LIKE 'Char';
Resultaat:
+-----------------------+ | 'Charlie' LIKE 'Char' | +-----------------------+ | 0 | +-----------------------+
Het resultaat is 0 wat betekent dat er geen match is. Dit komt omdat we geen jokerteken hebben gebruikt om andere tekens op te geven.
Voorbeeld 2 – De _ Jokerteken
We hebben ook de mogelijkheid om de _ . te gebruiken jokerteken om slechts één teken op te geven. Hier is een voorbeeld:
SELECT 'Charlie' LIKE 'Ch_rlie';
Resultaat:
+--------------------------+ | 'Charlie' LIKE 'Ch_rlie' | +--------------------------+ | 1 | +--------------------------+
De twee jokertekens kunnen indien nodig in een patroon worden gecombineerd:
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%' AS 'Result';
Resultaat:
+--------+ | Result | +--------+ | 1 | +--------+
Hier zijn er nog meer:
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';
Resultaat:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 1 | 1 | 1 | 1 | +----------+----------+----------+----------+
Laten we wat wijzigingen aanbrengen in dat voorbeeld, zodat we enkele voorbeelden kunnen zien van wanneer ze niet overeenkomen:
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';
Resultaat:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 0 | 0 | 0 | 0 | +----------+----------+----------+----------+
Voorbeeld 3 – Een databasevoorbeeld
De LIKE operator wordt vaak gebruikt binnen een WHERE clausule van een SELECT statement bij het opvragen van een database. Wanneer het op deze manier wordt gebruikt, worden de resultaten beperkt tot alleen die records die overeenkomen, maar we zien de daadwerkelijke resultaten (niet alleen een 1 of 0 ).
Hier is een voorbeeld van hoe we deze operator kunnen gebruiken binnen een databasequery:
SELECT ArtistId, ArtistName FROM Artists WHERE ArtistName LIKE 'B%';
Resultaat:
+----------+----------------+ | ArtistId | ArtistName | +----------+----------------+ | 4 | Buddy Rich | | 11 | Black Sabbath | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+----------------+
In dit geval was het een eenvoudige zoekopdracht die alle artiesten retourneert wiens namen beginnen met de letter B .
Hier is de volledige lijst van artiesten in die tabel:
SELECT ArtistId, ArtistName FROM Artists;
Resultaat:
+----------+------------------------+ | 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 | +----------+------------------------+
Voorbeeld 4 – Ontsnappen met het backslash-teken
Wat gebeurt er als een van de jokertekens in uw invoerreeks staat en u er een overeenkomst tegen moet uitvoeren? U kunt er ontsnappen met het backslash-teken (\ ). Hier is een voorbeeld van zo'n zoekopdracht met en zonder het escape-teken:
SELECT 'usr_123' LIKE 'usr_123' AS 'Without escape', 'usr_123' LIKE 'usr\_123' AS 'With escape';
Resultaat:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 1 | +----------------+-------------+
In dit geval kwamen ze allebei overeen, maar om verschillende redenen. De eerste regel komt overeen omdat het jokerteken aangeeft dat elk teken overeenkomt. De tweede regel kwam ook overeen, maar alleen omdat de invoerstring op de juiste plaats een onderstrepingsteken had.
Laten we de invoerstring iets veranderen zodat we een ander resultaat krijgen:
SELECT 'usr+123' LIKE 'usr_123' AS 'Without escape', 'usr+123' LIKE 'usr\_123' AS 'With escape';
Resultaat:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 0 | +----------------+-------------+
De unescaped-versie keerde positief terug, omdat de wildcard betekende dat we elk personage op die plek konden hebben. De escape-versie vermeldde expliciet dat alleen het onderstrepingsteken (_ ) zal overeenkomen. De invoerreeks had geen onderstrepingsteken op die plek en dus was het resultaat negatief.
Voorbeeld 5 – De ESCAPE Clausule
U kunt ook de ESCAPE . gebruiken clausule om uw eigen aangepaste escape-teken op te geven. Hier is een voorbeeld:
SELECT 'usr_123' LIKE 'usr|_123' ESCAPE '|' AS 'String 1', 'usr+123' LIKE 'usr|_123' ESCAPE '|' AS 'String 2';
Resultaat:
+----------+----------+ | String 1 | String 2 | +----------+----------+ | 1 | 0 | +----------+----------+
Voorbeeld 6 – Numerieke uitdrukkingen
De MySQL-implementatie van de LIKE operator staat toe dat numerieke uitdrukkingen worden gebruikt. Hier is een voorbeeld:
SELECT 1234 LIKE '12%', 1234 LIKE '12_';
Resultaat:
+-----------------+-----------------+ | 1234 LIKE '12%' | 1234 LIKE '12_' | +-----------------+-----------------+ | 1 | 0 | +-----------------+-----------------+