SQL LIKE: Präfix-, Suffix- und Teilstring-Filter

SQL LIKE filtert Zeilen, indem eine Textspalte mit einem Muster aus SQL-Wildcards verglichen wird. Die Wildcard % steht für null oder mehr Zeichen, _ für genau ein Zeichen. Das passt für SQL-Starts-With-Filter ('präfix%'), Suffix-Filter ('%suffix') und Teilstring-Filter ('%begriff%').

SQL LIKE Beispiel für Präfix-Matching

Ausgabe:

+-------+----------------+
| name  | email          |
+-------+----------------+
| Alina | [email protected] |
| Alma  | [email protected]  |
+-------+----------------+
2 row(s)

So filtert LIKE ‘Al%’ Zeilen

1. CREATE TABLE und INSERT füllen kunden mit vier Zeilen.
2. name LIKE 'Al%' behält Namen, die mit Al starten; % deckt den restlichen Teil ab.
3. Mit einem normalen B-Tree-Index auf name kann ein Präfixmuster wie 'Al%' einen Index-Range-Scan nutzen.

Was ist der SQL-LIKE-Operator?

SQL LIKE vergleicht eine Textspalte mit einem Muster. LIKE passt auf den ganzen String (nicht nur auf einen Teilstring), außer du setzt % auf einer oder beiden Seiten. Ohne Wildcards verhält sich LIKE 'text' wie = 'text'. Ist die Spalte NULL, ergeben LIKE und NOT LIKE den Wert unbekannt, und die Zeile wird durch WHERE ausgefiltert.

Wildcard-Muster: %, _, und ESCAPE

% und _ decken die meisten Filterfälle ab. In einem SQL-WHERE-Wildcard-Muster kombinierst du festen Text mit % und _, um Präfix-, Suffix- und Teilstring-Matches auszudrücken:

Um nach einem echten % oder _ zu suchen, definierst du mit der ESCAPE-Klausel ein Escape-Zeichen:

SELECT bezeichnung FROM kennzahlen
WHERE bezeichnung LIKE '%100\%%' ESCAPE '\';

Das \ ist als Escape-Zeichen gesetzt, deshalb matcht \% ein echtes % statt als Wildcard zu wirken.

SQL NOT LIKE: Passende Zeilen ausschließen

NOT LIKE kehrt das Muster um. Eine SQL-Abfrage mit NOT LIKE gibt alle Zeilen zurück, bei denen das Muster nicht passt:

SELECT name FROM kunden
WHERE email NOT LIKE '%firma%';

Das gibt Ben und Carla zurück, also alle Personen, deren E-Mail firma nicht enthält. Zeilen, in denen die Spalte NULL ist, werden sowohl bei LIKE als auch bei NOT LIKE ausgeschlossen. Um NULLs einzuschließen, füge explizit OR column IS NULL hinzu.

Häufige Fehler mit SQL LIKE

Fehler: Annehmen, dass LIKE 'term' Teilstrings findet.

Falsch:

WHERE name LIKE 'li'

Richtig:

WHERE name LIKE '%li%'

Warum: LIKE vergleicht den kompletten String. Ohne % auf beiden Seiten muss der Wert exakt li entsprechen.

Fehler: Nach einem echten % ohne ESCAPE suchen.

Falsch:

WHERE rabatt LIKE '100%'

Richtig:

WHERE rabatt LIKE '100\%' ESCAPE '\'

Warum: Ohne ESCAPE wirkt % als Wildcard und trifft auf 100, 1000, 100EUR und alles andere, das mit 100 beginnt.

LIKE-Performance: Präfix vs. führende Wildcard

Mit einem normalen B-Tree-Index kann LIKE 'abc%' einen Index-Range-Scan nutzen. Muster mit führendem % (wie '%abc' oder '%abc%') verhindern einen Index-Seek, deshalb muss die Engine typischerweise deutlich mehr Zeilen scannen.

Für Teilstring-Suche auf großen Datenmengen ist Full-Text Search (FTS) besser geeignet als LIKE '%term%'.

Groß-/Kleinschreibung je nach Dialekt

Das LIKE-Verhalten bei Groß-/Kleinschreibung unterscheidet sich je nach Datenbank:

SQLite behandelt LIKE 'al%' und LIKE 'Al%' bei ASCII gleich. PRAGMA case_sensitive_like = ON schaltet auf exakte Groß-/Kleinschreibung um. ILIKE in PostgreSQL ist eine Erweiterung und kein Teil des SQL-Standards.

Wenn du Spalten mit LOWER() kapselst, funktioniert das zwar dialektübergreifend, verhindert aber Indexnutzung. Für gute Performance sind case-insensitive Kollationen oder dialektspezifische Operatoren meist die bessere Wahl.