In MariaDB ist das LIKE -Operator ermöglicht Ihnen den Musterabgleich. Es bestimmt, ob eine bestimmte Zeichenfolge mit einem bestimmten Muster übereinstimmt. Es gibt entweder 1 zurück (WAHR) oder 0 (FALSCH).
Ein Muster kann reguläre Zeichen sowie den % enthalten und _ Platzhalterzeichen.
Diese Platzhalterzeichen werden in der folgenden Tabelle erläutert.
| Platzhalterzeichen | Beschreibung |
|---|---|
% | Entspricht einer beliebigen Zeichenfolge mit null oder mehr Zeichen. Es kann entweder als Präfix oder Suffix verwendet werden, und es kann auch in der Mitte einer Zeichenfolge verwendet werden. |
_ | Entspricht jedem einzelnen Zeichen. |
Syntax
Die Syntax lautet wie folgt:
expr LIKE pat [ESCAPE 'escape_char']Beispiel
Angenommen, wir haben die folgende Tabelle:
SELECT * FROM Pets;Ergebnis:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Hier ist ein Beispiel, um zu demonstrieren, wie der LIKE Betreiber funktioniert.
SELECT *
FROM Pets
WHERE PetName LIKE 'F%';Ergebnis:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
In diesem Beispiel habe ich den LIKE verwendet Operator in Verbindung mit dem % Wildcard-Operator, um Haustiere zurückzugeben, deren Name mit dem Buchstaben F beginnt .
Groß-/Kleinschreibung
LIKE führt Groß-/Kleinschreibungsübereinstimmungen durch, wenn die Sortierung für den Ausdruck und das Muster Groß-/Kleinschreibung nicht berücksichtigt.
Daher können wir das vorherige Beispiel ändern, um einen Kleinbuchstaben f zu verwenden , und erhalten immer noch das gleiche Ergebnis:
SELECT *
FROM Pets
WHERE PetName LIKE 'f%';Ergebnis:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Wir können jedoch eine Übereinstimmung zwischen Groß- und Kleinschreibung erzwingen, indem wir COLLATE verwenden Klausel mit einer binären Sortierung. Alternativ können Sie CAST() verwenden um es in einen binären String zu zwingen.
Beispiel:
SELECT *
FROM Pets
WHERE PetName LIKE 'f%' COLLATE utf8_bin;Ergebnis:
Empty set (0.000 sec)
Es werden keine Ergebnisse zurückgegeben.
Aber wenn wir es in einen großen F ändern :
SELECT *
FROM Pets
WHERE PetName LIKE 'F%' COLLATE utf8_bin;Ergebnis:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Wie erwartet bekommen wir drei Übereinstimmungen.
Numerische Argumente
Numerische Argumente werden in binäre Zeichenfolgen umgewandelt.
SELECT *
FROM Pets
WHERE PetId LIKE 7;Ergebnis:
+-------+-----------+---------+---------+------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------+ | 7 | 3 | 2 | Bark | NULL | +-------+-----------+---------+---------+------+
Termine
Hier ist ein Beispiel, das das Jahr aus einem Datum abgleicht:
SELECT *
FROM Pets
WHERE DOB LIKE '2020%';Ergebnis:
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Sie können auch den LIKE verwenden Operator gegen das Ergebnis von Datumsfunktionen wie DAYNAME() , MONTHNAME() usw.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) LIKE 'Nov%';Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +-------+-----------+---------+---------+------------+
Der _ Wildcard-Operator
Der Unterstrich (_ ) Wildcard-Operator passt auf jedes einzelne Zeichen.
Beispiel:
SELECT *
FROM Pets
WHERE PetName LIKE '_e%';Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
In diesem Fall haben wir Tiernamen abgeglichen, bei denen das zweite Zeichen ein e ist .
Der Escape-Charakter
Manchmal kann es vorkommen, dass Sie nach einem Unterstrich oder einem Prozentzeichen suchen müssen. In solchen Fällen können Sie einen umgekehrten Schrägstrich verwenden (\ ), um diesen Zeichen zu entkommen. Dadurch wird verhindert, dass sie als Platzhalterzeichen interpretiert werden.
Angenommen, wir haben die folgende Tabelle:
SELECT * FROM Owners;Ergebnis:
+---------+-----------+----------+----------------+--------------------+ | 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] | +---------+-----------+----------+----------------+--------------------+
Beachten Sie, dass Besitzer 2 (Bart) eine E-Mail-Adresse hat, die einen Unterstrich enthält.
Hier ist ein Beispiel dafür, was passiert, wenn wir es nicht tun Entkommen Sie einem Unterstrich:
SELECT * FROM Owners
WHERE Email LIKE 'b_%';Ergebnis:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
In diesem Fall stimmte es mit zwei Zeilen überein. In diesem Fall spielte es keine Rolle, was das zweite Zeichen war – es passte zu beliebigen Charakter. Die Tatsache, dass die erste Zeile einen Unterstrich für das zweite Zeichen enthält, ist nur ein Zufall. Es hätte gepasst, auch wenn es etwas anderes gewesen wäre.
Aber was wäre, wenn wir nur die E-Mail-Adressen abgleichen wollten, die einen echten Unterstrich als zweites Zeichen haben?
Hier kommt das Escape-Zeichen ins Spiel.
SELECT * FROM Owners
WHERE Email LIKE 'b\_%';Ergebnis:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Jetzt erhalten wir nur noch eine Zeile – die Zeile, die den Unterstrich als zweites Zeichen enthält.
Escape-Zeichen ändern
Es ist möglich, das Escape-Zeichen zu ändern. Das geht mit dem ESCAPE Argument.
Beispiel:
SELECT * FROM Owners
WHERE Email LIKE 'b*_%' ESCAPE '*';Ergebnis:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
In diesem Fall habe ich den Stern (* ) als Fluchtzeichen.
Dies kann besonders praktisch sein, wenn Sie den umgekehrten Schrägstrich für andere Zwecke verwenden müssen, z. B. zum Codieren von Sonderzeichen. In solchen Fällen kann es vorkommen, dass Sie diese Zeichen „doppelt maskieren“ müssen, was verwirrend werden kann. Das Ändern des Escape-Zeichens kann daher in solchen Situationen helfen.
NULL-Werte
Der Prozentsatz (% ) Wildcard stimmt mit allem überein – fast. Eine Sache, die nicht übereinstimmt, ist NULL .
SELECT * FROM Owners
WHERE Email LIKE '%';Ergebnis:
+---------+-----------+----------+----------------+--------------------+ | 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] | +---------+-----------+----------+----------------+--------------------+
In unserer Tabelle gibt es zwei Zeilen mit NULL in der Email Spalte, aber diese werden hier nicht zurückgegeben.
Leistung
Abfragen, die den LIKE enthalten -Operator kann viel langsamer als andere Abfragen ausgeführt werden, und Sie sollten wahrscheinlich die Verwendung von LIKE vermeiden Betreiber, es sei denn, Sie brauchen ihn wirklich. Verwenden Sie den % Operator als Präfix kann besonders langsam sein.
Das heißt nicht, dass Sie es überhaupt nicht verwenden sollten. Das LIKE Operator ist ein integraler Bestandteil von SQL, und Sie werden auf viele Szenarien stoßen, in denen dies die einzige Option (oder zumindest die beste Option) sein wird.
Das NOT LIKE Betreiber
Sie können auch NOT LIKE verwenden um zu testen, ob ein String nicht funktioniert einem Muster entsprechen.
