In MySQL ist das LIKE -Operator führt den Musterabgleich mithilfe eines SQL-Musters durch.
Wenn die Zeichenfolge mit dem bereitgestellten Muster übereinstimmt, ist das Ergebnis 1 , andernfalls ist es 0 .
Das Muster muss nicht unbedingt eine wörtliche Zeichenfolge sein. Diese Funktion kann mit Zeichenfolgenausdrücken und Tabellenspalten verwendet werden.
Syntax
Die Syntax lautet wie folgt:
expr LIKE pat [ESCAPE 'escape_char']
Wobei expr ist die Eingabezeichenfolge und pat ist das Muster, für das Sie die Zeichenfolge testen.
Das optionale ESCAPE -Klausel können Sie ein Escape-Zeichen angeben. Das Standard-Escape-Zeichen ist \ , sodass Sie diese Klausel weglassen können, wenn Sie dies nicht ändern müssen.
Beispiel 1 – Grundlegende Verwendung
Hier ist ein Beispiel für die Verwendung dieses Operators in einem SELECT Aussage:
SELECT 'Charlie' LIKE 'Char%';
Ergebnis:
+------------------------+ | 'Charlie' LIKE 'Char%' | +------------------------+ | 1 | +------------------------+
Der Rückgabewert ist in diesem Fall 1 was bedeutet, dass die Eingabezeichenfolge mit dem Muster übereinstimmte. Insbesondere haben wir festgelegt, dass der Eingabestring mit Char beginnen soll und mit allem enden. Der % Zeichen entspricht einer beliebigen Anzahl von Zeichen (einschließlich Nullzeichen).
Folgendes passiert, wenn wir % löschen :
SELECT 'Charlie' LIKE 'Char';
Ergebnis:
+-----------------------+ | 'Charlie' LIKE 'Char' | +-----------------------+ | 0 | +-----------------------+
Das Rückgabeergebnis ist 0 was bedeutet, keine Übereinstimmung. Dies liegt daran, dass wir kein Platzhalterzeichen verwendet haben, um andere Zeichen anzugeben.
Beispiel 2 – Der _ Platzhalter
Wir haben auch die Möglichkeit, den _ zu verwenden Platzhalterzeichen, um nur ein einzelnes Zeichen anzugeben. Hier ist ein Beispiel:
SELECT 'Charlie' LIKE 'Ch_rlie';
Ergebnis:
+--------------------------+ | 'Charlie' LIKE 'Ch_rlie' | +--------------------------+ | 1 | +--------------------------+
Die beiden Platzhalterzeichen können bei Bedarf innerhalb eines Musters kombiniert werden:
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%' AS 'Result';
Ergebnis:
+--------+ | Result | +--------+ | 1 | +--------+
Hier sind noch einige:
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';
Ergebnis:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 1 | 1 | 1 | 1 | +----------+----------+----------+----------+
Nehmen wir einige Änderungen an diesem Beispiel vor, damit wir einige Beispiele sehen können, wenn sie nicht übereinstimmen:
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';
Ergebnis:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 0 | 0 | 0 | 0 | +----------+----------+----------+----------+
Beispiel 3 – Ein Datenbankbeispiel
Das LIKE Der Operator wird oft innerhalb eines WHERE verwendet -Klausel eines SELECT Anweisung beim Abfragen einer Datenbank. Wenn es auf diese Weise verwendet wird, werden die Ergebnisse auf nur die Datensätze eingegrenzt, die übereinstimmen, aber wir sehen die tatsächlichen Ergebnisse (nicht nur eine 1 oder 0 ).
Hier ist ein Beispiel dafür, wie wir diesen Operator in einer Datenbankabfrage verwenden können:
SELECT ArtistId, ArtistName FROM Artists WHERE ArtistName LIKE 'B%';
Ergebnis:
+----------+----------------+ | ArtistId | ArtistName | +----------+----------------+ | 4 | Buddy Rich | | 11 | Black Sabbath | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+----------------+
In diesem Fall war es eine einfache Abfrage, die alle Künstler zurückgibt, deren Namen mit dem Buchstaben B beginnen .
Hier ist die vollständige Liste der Künstler in dieser Tabelle:
SELECT ArtistId, ArtistName FROM Artists;
Ergebnis:
+----------+------------------------+ | 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 | +----------+------------------------+
Beispiel 4 – Escape mit dem Backslash-Zeichen
Was passiert, wenn eines der Platzhalterzeichen in Ihrer Eingabezeichenfolge enthalten ist und Sie eine Übereinstimmung damit durchführen müssen? Sie können es mit dem Backslash-Zeichen maskieren (\ ). Hier ist ein Beispiel für eine solche Suche mit und ohne Escape-Zeichen:
SELECT 'usr_123' LIKE 'usr_123' AS 'Without escape', 'usr_123' LIKE 'usr\_123' AS 'With escape';
Ergebnis:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 1 | +----------------+-------------+
In diesem Fall stimmten beide überein, aber aus unterschiedlichen Gründen. Die erste Zeile stimmte überein, da der Platzhalter angab, dass alle Zeichen übereinstimmen. Die zweite Zeile passte auch, aber nur, weil der Eingabestring zufällig an der richtigen Stelle einen Unterstrich hatte.
Lassen Sie uns die Eingabezeichenfolge leicht ändern, sodass wir ein anderes Ergebnis erhalten:
SELECT 'usr+123' LIKE 'usr_123' AS 'Without escape', 'usr+123' LIKE 'usr\_123' AS 'With escape';
Ergebnis:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 0 | +----------------+-------------+
Die Version ohne Escapezeichen war positiv, da der Platzhalter bedeutete, dass wir an dieser Stelle jedes beliebige Zeichen haben konnten. Die Escape-Version gab ausdrücklich an, dass nur der Unterstrich (_ ) Wird zusammenpassen. Die Eingabezeichenfolge hatte an dieser Stelle keinen Unterstrich, daher war das Ergebnis negativ.
Beispiel 5 – Der ESCAPE Klausel
Sie können auch den ESCAPE verwenden -Klausel, um Ihr eigenes benutzerdefiniertes Escape-Zeichen anzugeben. Hier ist ein Beispiel:
SELECT 'usr_123' LIKE 'usr|_123' ESCAPE '|' AS 'String 1', 'usr+123' LIKE 'usr|_123' ESCAPE '|' AS 'String 2';
Ergebnis:
+----------+----------+ | String 1 | String 2 | +----------+----------+ | 1 | 0 | +----------+----------+
Beispiel 6 – Numerische Ausdrücke
Die MySQL-Implementierung von LIKE Operator erlaubt die Verwendung von numerischen Ausdrücken. Hier ist ein Beispiel:
SELECT 1234 LIKE '12%', 1234 LIKE '12_';
Ergebnis:
+-----------------+-----------------+ | 1234 LIKE '12%' | 1234 LIKE '12_' | +-----------------+-----------------+ | 1 | 0 | +-----------------+-----------------+
