Datenbereinigung mit SQL: Duplikate entfernen, NULLs behandeln, Strings reparieren

Datenbereinigung ist ein entscheidender Schritt in jedem Datenprojekt. Unsaubere Daten können Analysen verfälschen, Business-Intelligence-Berichte in die Irre führen und sogar die Qualität von KI-Modellen erheblich beeinträchtigen. Daher lohnt es sich, von Anfang an auf saubere, konsistente Daten zu achten.

In der Praxis treten drei Kernprobleme besonders häufig auf:

  • Duplikate, die redundante Informationen enthalten und Aggregationen verzerren.
  • NULL-Werte, die zu unerwarteten Ergebnissen in Berechnungen und Abfragen führen können.
  • String-Chaos, wie überflüssige Leerzeichen, unterschiedliche Groß-/Kleinschreibung oder kleine Tippfehler, die Datensätze inkonsistent machen.

Ziel dieses Artikels ist es, dir praxisnahe SQL-Lösungen für diese typischen Datenprobleme zu zeigen. Du lernst, wie du Duplikate identifizierst und entfernst, NULL-Werte sinnvoll behandelst und Strings zuverlässig bereinigst – alles mit leicht nachvollziehbaren SQL-Beispielen.

SQL Datenbereinigung

Schritt 1: Duplikate identifizieren & entfernen

1.1 Duplikate erkennen

Duplikate entstehen, wenn derselbe Datensatz mehrfach in einer Tabelle vorkommt. Sie können Aggregationen verfälschen und die Analyse erschweren. Mit SQL kannst du Duplikate leicht identifizieren, zum Beispiel mit GROUP BY und HAVING COUNT(*) > 1. 

SELECT col1, col2, COUNT(*)
FROM customers
GROUP BY col1, col2
HAVING COUNT(*) > 1;

Dieses Beispiel zeigt alle Kundeneinträge, die mehrfach vorkommen.

1.2 Lösungsansätze

Es gibt mehrere Wege, Duplikate zu entfernen:

  • Methode A: Temporäre Tabelle oder Kopie mit DISTINCT erstellen.
    CREATE TABLE customers_clean AS SELECT DISTINCT * FROM customers;
  • Methode B: Löschen mit ROW_NUMBER() (CTE-Technik).
    WITH CTE AS (
  SELECT *, ROW_NUMBER() OVER(PARTITION BY col1, col2 ORDER BY id) AS rn
  FROM sales
)
DELETE FROM CTE WHERE rn > 1;
  • Methode C: GROUP BY verwenden und eine neue Tabelle für große Datensätze anlegen.

1.3 Prävention

Um Duplikate von vornherein zu vermeiden, solltest du:

  • Unique Constraints oder Primary Keys definieren.
  • Indexe nutzen, um die Datenkonsistenz sicherzustellen.

Schritt 2: NULL-Werte systematisch behandeln

2.1 NULLs finden

NULL-Werte stehen in SQL für „kein Wert“ oder „unbekannt“. Sie können zu fehlerhaften Berechnungen oder unerwarteten Ergebnissen führen. Du kannst NULLs einfach finden, indem du sie explizit abfragst: 

SELECT * 
FROM customers
WHERE email IS NULL;

Beachte den Unterschied zwischen COUNT(column) und COUNT(*):

  • COUNT(column) zählt nur nicht-NULL-Werte.
  • COUNT(*) zählt alle Zeilen, auch solche mit NULLs.

2.2 Strategien zur Behandlung

Je nach Anwendungsfall kannst du NULL-Werte unterschiedlich behandeln:

  • Ersetzen: Mit COALESCE(column, Ersatzwert) oder ISNULL().
    SELECT COALESCE(email, 'keine Angabe') FROM customers;
  • Löschen: NULL-Zeilen entfernen (Vorsicht – Datenverlust!).
    DELETE FROM customers WHERE email IS NULL;
  • Umwandeln: NULL in einen leeren String oder eine 0 konvertieren.

2.3 Fortgeschrittene Ansätze

In komplexeren Szenarien kannst du Default-Werte oder Geschäftslogik nutzen:

  • DEFAULT-Constraint: Legt automatisch einen Wert fest, wenn keiner angegeben wird.
  • Dynamisches Auffüllen mit CASE:
    UPDATE employees 
SET salary = CASE 
               WHEN salary IS NULL THEN (SELECT AVG(salary) FROM employees) 
               ELSE salary 
             END;

Schritt 2: NULL-Werte systematisch behandeln

2.1 NULLs finden

NULL-Werte stehen in SQL für „kein Wert“ oder „unbekannt“. Sie können zu fehlerhaften Berechnungen oder unerwarteten Ergebnissen führen. Du kannst NULLs einfach finden, indem du sie explizit abfragst: 

SELECT * 
FROM customers
WHERE email IS NULL;

Beachte den Unterschied zwischen COUNT(column) und COUNT(*):

  • COUNT(column) zählt nur nicht-NULL-Werte.
  • COUNT(*) zählt alle Zeilen, auch solche mit NULLs.

2.2 Strategien zur Behandlung

Je nach Anwendungsfall kannst du NULL-Werte unterschiedlich behandeln:

  • Ersetzen: Mit COALESCE(column, Ersatzwert) oder ISNULL().
    SELECT COALESCE(email, 'keine Angabe') FROM customers;
  • Löschen: NULL-Zeilen entfernen (Vorsicht – Datenverlust!).
    DELETE FROM customers WHERE email IS NULL;
  • Umwandeln: NULL in einen leeren String oder eine 0 konvertieren.

2.3 Fortgeschrittene Ansätze

In komplexeren Szenarien kannst du Default-Werte oder Geschäftslogik nutzen:

  • DEFAULT-Constraint: Legt automatisch einen Wert fest, wenn keiner angegeben wird.
  • Dynamisches Auffüllen mit CASE:
    UPDATE employees 
SET salary = CASE 
               WHEN salary IS NULL THEN (SELECT AVG(salary) FROM employees) 
               ELSE salary 
             END;

Schritt 3: Strings reparieren & normalisieren

3.1 Häufige String-Probleme

Strings enthalten oft unerwünschte Zeichen oder Inkonsistenzen, die Analysen erschweren. Typische Probleme sind:

  • Überflüssige Leerzeichen: Mit TRIM(), LTRIM() und RTRIM() entfernen.
  • Groß-/Kleinschreibung: Einheitlich formatieren mit UPPER(), LOWER() oder INITCAP() (DB-spezifisch).
  • Tippfehler/Inkonsistenzen: Beispiel: „GmbH“ vs. „Gmbh“.

3.2 String-Transformationen

Mit SQL lassen sich Strings systematisch anpassen:

  • Suchen & Ersetzen: REPLACE(column, 'old', 'new')
  • Teilstrings extrahieren: SUBSTRING(), LEFT(), RIGHT()
  • Pattern-Matching: LIKE mit Wildcards %

3.3 Regex für komplexe Fälle (DB-abhängig)

Für fortgeschrittene Bereinigungen kannst du reguläre Ausdrücke nutzen. Beispiel in PostgreSQL, um E-Mail-Adressen von unerwünschten Zeichen zu bereinigen: 

UPDATE users
SET email = REGEXP_REPLACE(email, '[^a-zA-Z0-9@._-]', '', 'g');

Schritt 4: Kombinierte Bereinigungspipeline

In der Praxis musst du oft mehrere Bereinigungsschritte kombinieren. Hier ein Beispiel, wie du Duplikate entfernst, NULL-Werte ersetzt und Strings normalisierst – alles in einer Pipeline.

Praxisbeispiel: Schritt-für-Schritt

  1. Duplikate entfernen.
  2. NULLs in der Spalte adresse durch einen leeren String ersetzen.
  3. Strings in der Spalte name trimmen und in Großbuchstaben umwandeln.

SQL-Skript-Beispiel

Das folgende Skript ist anpassbar für MySQL, PostgreSQL oder SQL Server:

-- Schritt 1: Duplikate löschen
WITH CTE AS (
  SELECT *, ROW_NUMBER() OVER(PARTITION BY col1, col2 ORDER BY id) AS rn
  FROM tabelle
)
DELETE FROM CTE WHERE rn > 1;

-- Schritt 2: NULLs behandeln
UPDATE tabelle 
SET adresse = COALESCE(adresse, '');

-- Schritt 3: Strings normalisieren
UPDATE tabelle 
SET name = UPPER(TRIM(name)),
    stadt = INITCAP(REPLACE(stadt, 'ß', 'ss'));

Schritt 5: Best Practices & Performance-Tipps

Sicherheit first

  • Vor Löschoperationen immer ein Backup erstellen:
    CREATE TABLE backup AS SELECT * FROM original_tabelle;
  • Transaktionen verwenden, um Änderungen rückgängig machen zu können:
    BEGIN;
-- Änderungen durchführen
ROLLBACK; -- bei Fehlern

Performance-Optimierung

  • Indexe temporär deaktivieren, um Massenupdates zu beschleunigen.
  • Batch-Verarbeitung verwenden, um große Tabellen schrittweise zu bearbeiten.

Wartbarkeit

  • SQL-Skripte gut kommentieren, um die Logik nachvollziehbar zu machen.
  • Automatisierungen z. B. mit Stored Procedures einführen, um wiederkehrende Bereinigungen effizient auszuführen.

Fazit: Saubere Daten mit Routine

Saubere Daten sind die Grundlage für valide Analysen, Business-Intelligence-Reports und KI-Modelle. Durch gezielte Bereinigung von Duplikaten, NULL-Werten und inkonsistenten Strings stellst du sicher, dass deine Daten zuverlässig und aussagekräftig sind.

Datenbereinigung ist kein einmaliges Projekt, sondern ein kontinuierlicher Prozess. Regelmäßige Kontrolle, präventive Maßnahmen wie Constraints und automatisierte Skripte helfen, die Qualität langfristig hoch zu halten.

Für komplexere Pipelines können Tools wie dbt oder Python unterstützend eingesetzt werden, um Datenaufbereitung effizient und reproduzierbar zu gestalten.