SQL-Whitespace trimmen: Ein Guide für MySQL, PostgreSQL & mehr

Das Entfernen von Leerzeichen aus Strings ist eine häufige Aufgabe beim Bereinigen und Aufbereiten von Daten. Verschiedene Datenbanken implementieren String-Funktionen unterschiedlich, aber alle sollen deine Daten sauberer und konsistenter machen. In diesem Guide zeigen wir dir, wie du Whitespace mit SQL in verschiedenen Datenbanken trimmst, darunter MySQL, PostgreSQL, SQL Server und SQLite.

Warum Whitespace trimmen?

Leerzeichen landen manchmal versehentlich in den Daten und führen zu Problemen mit der Konsistenz und Genauigkeit von Abfragen und Reports. Wenn du sie entfernst, funktionieren Vergleiche und Joins wie erwartet.

Probier es selbst aus

Du willst diese TRIM-Funktionen direkt testen? Mit unserem Tool SQL Syntax Checker kannst du deine SQL-Abfragen validieren – es unterstützt die Dialekte von MySQL, PostgreSQL, SQL Server und SQLite.

Zum Üben mit einer echten Datenbank probier DB Fiddle aus – ein kostenloses Online-Tool, mit dem du SQL-Abfragen gegen MySQL-, PostgreSQL- und SQLite-Datenbanken direkt im Browser ausführen kannst.

Whitespace trimmen in MySQL

In MySQL stehen dir mehrere Funktionen zum Trimmen von Whitespace zur Verfügung. Wir konzentrieren uns auf TRIM(), mit der du führende, nachgestellte oder beide Arten von Leerzeichen entfernen kannst.

Syntax

TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)

• BOTH: Entfernt sowohl führende als auch nachgestellte Zeichen.
• LEADING: Entfernt Zeichen am Anfang.
• TRAILING: Entfernt Zeichen am Ende.
• remstr: Das zu entfernende Zeichen oder Leerzeichen (Standard ist Whitespace).

Beispiel

SELECT TRIM('   Hello World   ') AS trimmed_string;

Erwartete Ausgabe:

+----------------+
| trimmed_string |
+----------------+
| Hello World    |
+----------------+

Beispiel mit einem bestimmten Zeichen

SELECT TRIM(BOTH '-' FROM '---Hello World---') AS trimmed_string;

Erwartete Ausgabe:

+----------------+
| trimmed_string |
+----------------+
| Hello World    |
+----------------+

Whitespace trimmen in PostgreSQL

PostgreSQL bietet eine ähnliche TRIM()-Funktion.

Beispiel

SELECT TRIM('   PostgreSQL User   ') AS trimmed_string;

Erwartete Ausgabe:

+------------------+
| trimmed_string   |
+------------------+
| PostgreSQL User  |
+------------------+

Spezialisierte Funktionen verwenden

PostgreSQL unterstützt außerdem LTRIM() und RTRIM().

• LTRIM(): Entfernt führende Leerzeichen.
• RTRIM(): Entfernt nachgestellte Leerzeichen.

Beispiele

SELECT LTRIM('   Leading whitespace') AS ltrimmed_string;
SELECT RTRIM('Trailing whitespace   ') AS rtrimmed_string;

Erwartete Ausgabe:

+--------------------+
| ltrimmed_string    |
+--------------------+
| Leading whitespace |
+--------------------+

+--------------------+
| rtrimmed_string    |
+--------------------+
| Trailing whitespace|
+--------------------+

Whitespace trimmen in SQL Server

SQL Server 2017 und neuere Versionen unterstützen die Standardfunktion TRIM(), die standardmäßig führende und nachgestellte Leerzeichen entfernt.

TRIM() verwenden (SQL Server 2017+)

SELECT TRIM('   SQL Server   ') AS trimmed_string;

Erwartete Ausgabe:

+----------------+
| trimmed_string |
+----------------+
| SQL Server     |
+----------------+

LTRIM() und RTRIM() verwenden (alle Versionen)

Bei älteren Versionen von SQL Server oder wenn du nur eine Seite trimmen willst, verwende LTRIM() und RTRIM().

SELECT LTRIM('   SQL Server') AS ltrimmed_string;
SELECT RTRIM('SQL Server   ') AS rtrimmed_string;

Erwartete Ausgabe:

+-----------------+
| ltrimmed_string |
+-----------------+
| SQL Server      |
+-----------------+

+-----------------+
| rtrimmed_string |
+-----------------+
| SQL Server      |
+-----------------+

Um in älteren Versionen führende und nachgestellte Leerzeichen zu entfernen, verschachtelst du die Funktionen:

SELECT LTRIM(RTRIM('   SQL Server   ')) AS fully_trimmed_string;

Erwartete Ausgabe:

+----------------------+
| fully_trimmed_string |
+----------------------+
| SQL Server           |
+----------------------+

Whitespace trimmen in SQLite

In SQLite verwendest du die Funktion TRIM(), die sich ähnlich wie die Implementierung in MySQL verhält.

Beispiel

SELECT TRIM('   Hello SQLite   ') AS trimmed_string;

Erwartete Ausgabe:

+---------------+
| trimmed_string|
+---------------+
| Hello SQLite  |
+---------------+

Praxisbeispiel: Daten in einer Tabelle bereinigen

Hier ein Beispiel aus der Praxis, das zeigt, wie du mit TRIM-Funktionen Daten in einer Tabelle bereinigst. Angenommen, du hast eine Tabelle customers mit Whitespace-Problemen:

CREATE TABLE customers (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100)
);

INSERT INTO customers VALUES
    (1, '  John Doe  ', '  john@example.com'),
    (2, 'Jane Smith   ', 'jane@example.com  '),
    (3, '   Bob Wilson', '   bob@example.com   ');

UPDATE customers
SET name = TRIM(name),
    email = TRIM(email);

SELECT id, CONCAT('[', name, ']') AS name, CONCAT('[', email, ']') AS email
FROM customers;

Dieses Muster funktioniert in allen gängigen Datenbanken, auch wenn die genaue Syntax für CONCAT leicht abweichen kann.

Fazit

Whitespace in SQL zu trimmen ist eine einfache, aber wirkungsvolle Operation, die bei der Normalisierung und Aufbereitung von Daten hilft. Jede Datenbank hat ihre eigene Syntax und Möglichkeiten, aber die Kernfunktion bleibt gleich. Nutze diese Trim-Funktionen, damit deine Daten genau so sind, wie sie sein sollen – für präzise Abfragen und Reports in all deinen SQL-Datenbanken.