SQL SUBSTRING Guide

SUBSTRING liefert einen Teil eines Strings zurück – ab der Position, die du angibst, und so viele Zeichen, wie du willst. So holt SQL ein Präfix, einen Code oder eine E-Mail-Domain aus einer Textspalte. Die Beispiele funktionieren in PostgreSQL, MySQL, SQLite und SQL Server.

So verwendest du SUBSTRING

Gib SUBSTRING einen String, die Startposition (das erste Zeichen ist 1) und die Anzahl der Zeichen. Lässt du die Länge weg, bekommst du alles bis zum Ende:

SUBSTRING(string, start, length)

SELECT SUBSTRING('Joe Bloggs', 1, 3);
-- Output: Joe

-- No length: the rest of the string (SQL Server needs all three arguments)
SELECT SUBSTRING('Joe Bloggs', 5);
-- Output: Bloggs

In einer echten Abfrage ist der String meist eine Spalte. Bestellnummern wie ORD-2024-001 enthalten das Jahr in den Zeichen 5 bis 8:

-- Input: orders
-- order_number
-- ------------
-- ORD-2024-001
-- ORD-2025-014
-- ORD-2026-102

SELECT order_number, SUBSTRING(order_number, 5, 4) AS year
FROM orders;

-- Output:
-- order_number | year
-- -------------+-----
-- ORD-2024-001 | 2024
-- ORD-2025-014 | 2025
-- ORD-2026-102 | 2026

Was du wissen solltest

• Positionen beginnen bei 1, nicht bei 0. Ein negativer Start zählt vom Ende des Strings rückwärts, aber nur in MySQL und SQLite:

SELECT SUBSTRING('Joe Bloggs', -6, 6);
-- Output: Bloggs
-- PostgreSQL and SQL Server return '' (an empty string) instead

• Über das Ende hinauszugehen ist kein Fehler. Du bekommst die vorhandenen Zeichen oder einen leeren String, wenn der Start hinter dem Ende liegt:

SELECT SUBSTRING('Bob', 1, 10);
-- Output: Bob

SELECT SUBSTRING('Hello', 10, 5);
-- Output: '' (an empty string)

• NULL rein, NULL raus. Pack den Aufruf in COALESCE, wenn du stattdessen einen Wert brauchst:

SELECT SUBSTRING(NULL, 1, 5);
-- Output: NULL
-- SQL Server rejects a bare NULL here, but a NULL column gives NULL

• Filtere nach einem Präfix mit LIKE, nicht mit SUBSTRING. WHERE SUBSTRING(product_code, 1, 3) = 'ELE' liefert dieselben Zeilen wie WHERE product_code LIKE 'ELE%', aber nur die LIKE-Variante kann einen Index auf product_code nutzen.

Alternative Syntax

Du wirst auch SUBSTR sehen, einen anderen Namen für SUBSTRING, sowie LEFT und RIGHT, die Zeichen von einem der beiden Enden nehmen:

-- Not in SQL Server
SELECT SUBSTR('Joe Bloggs', 1, 3);
-- Output: Joe

-- Not in SQLite: use SUBSTRING('Joe Bloggs', 1, 3) and SUBSTRING('Joe Bloggs', -6)
SELECT LEFT('Joe Bloggs', 3);
-- Output: Joe

SELECT RIGHT('Joe Bloggs', 6);
-- Output: Bloggs

-- PostgreSQL and MySQL: the standard SQL form
SELECT SUBSTRING('Joe Bloggs' FROM 1 FOR 3);
-- Output: Joe

Um nach einem bestimmten Zeichen zu starten, ermittle zuerst seine Position:

SELECT INSTR('joe@example.com', '@');
-- Output: 4
-- PostgreSQL: POSITION('@' IN 'joe@example.com'); SQL Server: CHARINDEX('@', 'joe@example.com')

Wann solltest du SUBSTRING verwenden?

Greif zu SUBSTRING, wenn der benötigte Teil eines Strings an einer bekannten Position steht oder direkt nach einem Zeichen, das du finden kannst. Die meisten Anwendungsfälle gehören zu einem dieser vier.

Die ersten Zeichen nehmen

Codes und Namen tragen oft am Anfang Bedeutung: die Kategorie in einem Produktcode, eine Initiale, eine kurze Vorschau einer langen Beschreibung. SUBSTRING(column, 1, n) nimmt die ersten n Zeichen.

Felder aus Werten mit festem Format holen

Wenn jeder Wert dasselbe Layout hat, steht jeder Teil in jeder Zeile an derselben Position: die Vorwahl in einer Telefonnummer wie (303) 555-0147, das Jahr in ORD-2024-001 oder die Felder eines Datensatzes mit fester Breite aus einem älteren System.

Text nach einem Trennzeichen extrahieren

E-Mail-Domains, Dateiendungen und URL-Pfade beginnen nach einem Zeichen, dessen Position von Zeile zu Zeile wechselt. Ermittle die Position mit INSTR, starte ein Zeichen später und nimm den Rest des Strings.

Die letzten Zeichen behalten

Wer eine Karten- oder Kontonummer maskieren oder ein Suffix lesen will, muss vom Ende rückwärts zählen. Berechne den Start aus der Länge des Strings oder nutz in MySQL und SQLite einen negativen Start.

Praxisbeispiele für SUBSTRING

Produkte nach der Kategorie im Code zählen

Produktcodes beginnen mit einer dreibuchstabigen Kategorie. Gruppiere nach diesem Präfix, um die Produkte pro Kategorie zu zählen:

-- Input: products
-- product_code | name
-- -------------+-----------
-- ELE-1234     | USB-C Hub
-- FUR-0087     | Desk Chair
-- ELE-5521     | Webcam
-- OFF-2210     | Stapler

SELECT SUBSTRING(product_code, 1, 3) AS category, COUNT(*) AS products
FROM products
GROUP BY SUBSTRING(product_code, 1, 3)
ORDER BY category;

-- Output:
-- category | products
-- ---------+---------
-- ELE      | 2
-- FUR      | 1
-- OFF      | 1

Einen Datensatz mit fester Breite parsen

Exporte aus älteren Systemen packen Felder oft ohne Trennzeichen an feste Positionen. Hier belegt der Name 8 Zeichen (mit Leerzeichen aufgefüllt, die TRIM entfernt), das Geburtsdatum die nächsten 8 und der Stadtcode die letzten 3:

-- Input: legacy_data
-- record
-- -------------------
-- JOHNDOE 19850315NYC
-- MARYLEE 19780912CHI
-- JANEROE 19900722LAX

SELECT
  TRIM(SUBSTRING(record, 1, 8)) AS name,
  SUBSTRING(record, 9, 8) AS birth_date,
  SUBSTRING(record, 17, 3) AS city_code
FROM legacy_data;

-- Output:
-- name    | birth_date | city_code
-- --------+------------+----------
-- JOHNDOE | 19850315   | NYC
-- MARYLEE | 19780912   | CHI
-- JANEROE | 19900722   | LAX

Die Endung jeder Datei ermitteln

Finde den Punkt und nimm alles danach. Die WHERE-Klausel überspringt Dateien ohne Punkt:

-- Input: documents
-- filename
-- ---------------
-- q3-report.pdf
-- budget.xlsx
-- README
-- team-photo.jpeg

SELECT
  filename,
  SUBSTRING(filename, INSTR(filename, '.') + 1) AS extension
FROM documents
WHERE INSTR(filename, '.') > 0;

-- Output:
-- filename        | extension
-- ----------------+----------
-- q3-report.pdf   | pdf
-- budget.xlsx     | xlsx
-- team-photo.jpeg | jpeg

In PostgreSQL verwendest du POSITION('.' IN filename) statt INSTR. In SQL Server nimmst du CHARINDEX('.', filename) und gibst eine Länge an, etwa LEN(filename).

Eine Kartennummer maskieren

Nicht alle Kartennummern haben 16 Ziffern, daher schneidet eine feste Startposition American-Express-Nummern ab. Zähl stattdessen vom Ende rückwärts:

-- Input: payments
-- customer_name | card_number
-- --------------+-----------------
-- Lena Fischer  | 4111111111111111
-- Marcus Reid   | 5500005555555559
-- Aiko Tanaka   | 378282246310005

-- Wrong: position 13 only works for 16-digit cards
SELECT customer_name, '**** ' || SUBSTRING(card_number, 13, 4) AS masked_card
FROM payments;

-- Output:
-- customer_name | masked_card
-- --------------+------------
-- Lena Fischer  | **** 1111
-- Marcus Reid   | **** 5559
-- Aiko Tanaka   | **** 005

-- Right: start 4 characters from the end
SELECT customer_name, '**** ' || SUBSTRING(card_number, LENGTH(card_number) - 3, 4) AS masked_card
FROM payments;

-- Output:
-- customer_name | masked_card
-- --------------+------------
-- Lena Fischer  | **** 1111
-- Marcus Reid   | **** 5559
-- Aiko Tanaka   | **** 0005

In MySQL und SQL Server verbindest du die Strings mit CONCAT() statt ||. SQL Server braucht außerdem LEN() statt LENGTH().

Weiterführende Infos zu SUBSTRING

In diesem Blog:

• SQL LIKE Guide: Text finden, der mit einem Muster beginnt, endet oder es enthält
• SQL COALESCE Guide: die NULLs ersetzen, die SUBSTRING durchreicht
• SQL GROUP BY Guide: Zeilen nach einem extrahierten Wert gruppieren und zählen
• SQL Datumsformat Guide: Datumswerte formatieren und Datumsteile ohne String-Zerlegung auslesen

Offizielle Dokumentation:

• PostgreSQL: String-Funktionen
• MySQL: SUBSTRING()
• SQLite: substr()
• SQL Server: SUBSTRING