In MariaDB ist das NOT LIKE -Operator wird verwendet, um zu testen, ob ein String nicht funktioniert oder nicht einem Muster entsprechen. Es gibt die Umkehrung von LIKE zurück Operator. Es ist dasselbe wie das Anwenden des NOT Operator gegen das ganze LIKE Ausdruck.
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 NOT 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 für die Verwendung von NOT LIKE gegen diese Tabelle:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
In diesem Beispiel habe ich NOT LIKE verwendet in Verbindung mit dem % Wildcard-Operator, um Haustiere zurückzugeben, deren Name nicht ist Beginnen Sie mit dem Buchstaben F .
Dies ist die entgegengesetzte Ergebnismenge, die wir erhalten hätten, wenn wir nur LIKE verwendet hätten . In diesem Fall würden wir nur Ergebnisse erhalten, bei denen der Name des Haustiers mit dem Buchstaben F beginnt .
Groß-/Kleinschreibung
NOT 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 NOT LIKE 'f%';Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
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 NOT 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 | | 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 | +-------+-----------+---------+---------+------------+
Diesmal wurde die gesamte Tabelle zurückgegeben. Dies liegt daran, dass nichts mit dem Kleinbuchstaben f übereinstimmt .
Aber wenn wir es in einen großen F ändern :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
Wie erwartet bekommen wir fünf Spiele. Die Zeilen, in denen der Tiername mit F beginnt sind ausgeschlossen.
Numerische Argumente
Numerische Argumente werden in binäre Zeichenfolgen umgewandelt.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Termine
Hier ist ein Datumsbeispiel:
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
Sie können auch den NOT LIKE verwenden Operator gegen das Ergebnis von Datumsfunktionen wie DAYNAME() , MONTHNAME() usw.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Der _ Wildcard-Operator
Der Unterstrich (_ ) Wildcard-Operator passt auf jedes einzelne Zeichen.
Beispiel:
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Ergebnis:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 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 | +-------+-----------+---------+---------+------------+
In diesem Fall haben wir Kosenamen zurückgegeben, bei denen das zweite Zeichen nicht ist ein e .
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 NOT LIKE 'b_%';Ergebnis:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
In diesem Fall wurden nur zwei Zeilen zurückgegeben. Die beiden Zeilen, in denen die E-Mail-Adresse mit einem b beginnt, wurden ausgeschlossen , gefolgt von einem weiteren Zeichen und einer beliebigen Anzahl von Zeichen. Außerdem wurden die Zeilen mit null ausgeschlossen E-Mail-Adresse.
Da wir den Unterstrich jedoch nicht maskiert haben, spielte es keine Rolle, wie das zweite Zeichen lautete – es passte zu irgendeinem 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 NOT LIKE 'b\_%';Ergebnis:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
Wir können sehen, dass Burt zu den Ergebnissen hinzugefügt wurde.
Escape-Zeichen ändern
Es ist möglich, das Escape-Zeichen zu ändern. Das geht mit dem ESCAPE Argument.
Beispiel:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b*_%' ESCAPE '*';Ergebnis:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
In diesem Fall habe ich den Stern (* ) als Fluchtzeichen.
Dies kann 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.
