SQL LIKE Guide

LIKE prüft, ob Text einem Muster entspricht. Dabei steht % für eine beliebige Folge von Zeichen und _ für genau ein Zeichen. So findest du Werte, die einen Text enthalten, damit beginnen oder damit enden. Die Beispiele funktionieren in PostgreSQL, MySQL, SQLite und SQL Server.

So verwendest du LIKE

LIKE vergleicht einen Wert mit einem Muster. Das Muster muss auf den gesamten Wert passen, wobei zwei Platzhalter die Lücken füllen: % passt auf beliebig viele Zeichen (auch auf keins) und _ auf genau eins. NOT LIKE liefert das Gegenteil.

expression [NOT] LIKE pattern [ESCAPE escape_character]

-- In SQL Server, LIKE only works in a condition, such as a WHERE clause
SELECT 'Joe Bloggs' LIKE 'Jo%';
-- Output: true

SELECT 'Joe Bloggs' LIKE 'J_e%';
-- Output: true

SELECT 'Joe Bloggs' LIKE 'Bloggs';
-- Output: false

Das letzte Ergebnis ist false, weil das Muster ohne Platzhalter dem gesamten Wert entsprechen muss. In einer Abfrage steht LIKE meist in der WHERE-Klausel:

-- Input: customers
-- id | name
-- ---+-------------
-- 1  | Joe Bloggs
-- 2  | Jane Doe
-- 3  | Joanna Smith
-- 4  | Bob Jones

SELECT name
FROM customers
WHERE name LIKE 'Jo%';

-- Output:
-- name
-- ------------
-- Joe Bloggs
-- Joanna Smith

Wichtige Regeln

• LIKE in PostgreSQL unterscheidet Groß- und Kleinschreibung. Die anderen Datenbanken ignorieren sie standardmäßig, aber in PostgreSQL ist 'Smith' LIKE 'smith' false. Wandle beide Seiten in Kleinbuchstaben um, etwa mit LOWER(name) LIKE '%smith%', wenn die Schreibweise keine Rolle spielen soll.
• NULL passt nie. NULL LIKE '%' ergibt NULL, nicht true. Zeilen, in denen die Spalte NULL ist, werden also sowohl von LIKE als auch von NOT LIKE ausgeschlossen. Füge OR column IS NULL hinzu, wenn du sie haben willst.

SELECT NULL LIKE '%';
-- Output: NULL

• Maskiere % und _, um sie wörtlich zu suchen. Setze ein Escape-Zeichen vor den Platzhalter und gib es mit ESCAPE an:

-- Input: discounts
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats
-- 2  | Spend 50, save 10
-- 3  | Up to 25% off shoes

-- Without escaping, the % after 50 is a wildcard
SELECT * FROM discounts
WHERE description LIKE '%50%%';

-- Output:
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats
-- 2  | Spend 50, save 10

-- With ESCAPE '\', the \% matches a real percent sign
-- (in MySQL, write ESCAPE '\\': a single backslash escapes the quote)
SELECT * FROM discounts
WHERE description LIKE '%50\%%' ESCAPE '\';

-- Output:
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats

• Ein führendes % kann keinen Index nutzen. Eine Präfixsuche wie LIKE 'INV-2026-%' kann einen Index auf der Spalte verwenden, aber LIKE '%widget%' muss jede Zeile prüfen. Für die Wortsuche in großen Textmengen nimmst du besser die Volltextsuche deiner Datenbank.

Alternative Syntax

Dir begegnen auch diese datenbankspezifischen Extras:

-- PostgreSQL: ILIKE ignores case
SELECT 'SMITH' ILIKE 'smith';
-- Output: true

-- SQL Server: [ ] in a LIKE pattern matches one character from a set or range
SELECT CASE WHEN 'B12' LIKE '[A-C]%' THEN 'match' ELSE 'no match' END;
-- Output: match

-- MySQL: REGEXP for regular expressions (PostgreSQL uses ~)
SELECT 'A12-345' REGEXP '^A[0-9]{2}-[0-9]{3}$';
-- Output: 1

Um zu prüfen, ob Text einen festen String ohne Muster enthält, suchst du dessen Position. Das Ergebnis ist 0, wenn der String nicht vorkommt:

SELECT INSTR('FinTech Corp', 'Tech');
-- Output: 4

-- PostgreSQL: POSITION('Tech' IN 'FinTech Corp')
-- SQL Server: CHARINDEX('Tech', 'FinTech Corp')

CONTAINS() in SQL Server ist kein Teilstring-Test, sondern ein Prädikat für die Volltextsuche, das einen Volltextindex braucht.

Wann solltest du LIKE verwenden?

Verwende LIKE, wenn du einen Teil eines Werts kennst, aber nicht den ganzen. Die meisten Anwendungsfälle fallen in eine dieser vier Kategorien.

Text finden, der ein Wort enthält

Setze % auf beide Seiten des Worts. '%Tech%' findet „Tech Solutions Inc“, „FinTech Corp“ und „Technology Partners“, weil es auch innerhalb längerer Wörter passt.

Anfang oder Ende eines Werts finden

Setze % nur ans Ende, um ein Präfix zu finden, etwa 'INV-2026-%', oder nur an den Anfang für ein Suffix, etwa '%.pdf' oder '%@gmail.com'. Präfixsuchen sind die, die ein Index beschleunigen kann.

Ein festes Format prüfen

_ steht für genau ein Zeichen, daher kann ein Muster die Form eines Werts beschreiben: '___-___-____' für eine Telefonnummer, 'A__-___' für einen Produktcode. Mit NOT LIKE findet dasselbe Muster die Werte, die vom Format abweichen.

Suchen ohne Rücksicht auf Groß- und Kleinschreibung

Nutzer tippen „smith“, in den Daten steht „Smith“. Wandle beide Seiten mit LOWER() in Kleinbuchstaben um, dann ignoriert die Suche die Schreibweise, sogar in PostgreSQL.

Praxisbeispiele für LIKE

Nach einem von mehreren Wörtern suchen

Kombiniere Muster mit OR, um Produkte zu finden, die auf eines davon passen:

-- Input: products
-- id | name
-- ---+-----------------
-- 1  | Gaming laptop
-- 2  | Spiral notebook
-- 3  | Desk lamp
-- 4  | Desktop computer

SELECT * FROM products
WHERE name LIKE '%laptop%'
   OR name LIKE '%notebook%'
   OR name LIKE '%computer%';

-- Output:
-- id | name
-- ---+-----------------
-- 1  | Gaming laptop
-- 2  | Spiral notebook
-- 4  | Desktop computer

Die Rechnungen dieses Jahres finden

Rechnungsnummern beginnen mit einem Typ und einer Jahreszahl, daher findet ein Präfixmuster die Rechnungen von 2026 und überspringt Gutschriften:

-- Input: invoices
-- invoice_no    | customer
-- --------------+----------
-- INV-2026-0012 | Northwind
-- INV-2025-0981 | Contoso
-- CN-2026-0003  | Northwind
-- INV-2026-0040 | Fabrikam

SELECT * FROM invoices
WHERE invoice_no LIKE 'INV-2026-%';

-- Output:
-- invoice_no    | customer
-- --------------+----------
-- INV-2026-0012 | Northwind
-- INV-2026-0040 | Fabrikam

Telefonnummern im falschen Format finden

Ein _ pro Zeichen beschreibt das erwartete Format, und NOT LIKE listet die Zeilen auf, die du bereinigen musst:

-- Input: customers
-- name      | phone
-- ----------+---------------
-- Ana Lima  | 555-010-1234
-- Ben Ode   | (555) 010-9876
-- Cara Diaz | 5550104321
-- Dev Rao   | 555-010-5555

SELECT name, phone FROM customers
WHERE phone NOT LIKE '___-___-____';

-- Output:
-- name      | phone
-- ----------+---------------
-- Ben Ode   | (555) 010-9876
-- Cara Diaz | 5550104321

Einen Nachnamen in beliebiger Schreibweise finden

Namen in Groß- oder Kleinbuchstaben werden trotzdem gefunden, wenn beide Seiten in Kleinbuchstaben umgewandelt werden:

-- Input: customers
-- id | name
-- ---+------------
-- 1  | Anna Smith
-- 2  | BEN SMITH
-- 3  | Dana Jones
-- 4  | carla smith

SELECT * FROM customers
WHERE LOWER(name) LIKE '%smith%';

-- Output:
-- id | name
-- ---+------------
-- 1  | Anna Smith
-- 2  | BEN SMITH
-- 4  | carla smith

Weiterführende Infos zu LIKE

In diesem Blog:

• SQL SUBSTRING Guide: einen Teil eines Strings extrahieren, nachdem du ihn gefunden hast
• SQL Not Equal Guide: NOT LIKE und die anderen Wege, Zeilen auszuschließen
• SQL CASE Statement Guide: Zeilen anhand von Bedingungen kennzeichnen, auch mit LIKE-Mustern
• Indizes in PostgreSQL erstellen: die Indizes, die Präfixsuchen schnell machen
• MySQL CREATE INDEX Tutorial: dasselbe für MySQL

Offizielle Dokumentation:

• PostgreSQL: LIKE
• MySQL: LIKE
• SQLite: Die Operatoren LIKE, GLOB, REGEXP, MATCH und extract
• SQL Server: LIKE