Typische Fehler beim Arbeiten mit Daten

Mit Datenbanken zu arbeiten ist wie das Leben eines Programmierers: voller Überraschungen. Selbst der erfahrenste Entwickler kann mal Mist bauen – sei es ein versehentliches Löschen von Daten, der Versuch, ein Duplikat einzufügen, oder das Brechen von Integritätsregeln. Wichtig ist nicht nur, solche Fehler zu vermeiden, sondern auch zu wissen, wie man sie wieder geradebiegt, falls sie doch passieren. Lass uns mal ein paar der typischsten Fehler anschauen.

Fehler Nr. 1: Fehlende WHERE-Bedingung

Der absolute Klassiker, den Anfänger (und, seien wir ehrlich, manchmal auch Profis) machen: Sie vergessen, ein WHERE in ihren Update- oder Delete-Query einzubauen. Queries ohne WHERE updaten oder löschen alle Zeilen der Tabelle.

-- So bitte nicht:
UPDATE students SET status = 'absolviert';

-- Oder so:
DELETE FROM students;

Folgen: Stell dir vor, du führst so einen Query aus und merkst danach, dass deine students-Tabelle mit allen Studentendaten plötzlich leer ist. Und das Schlimmste: Die Daten sind weg, wenn du kein Backup hast oder keine Transaktionen genutzt hast (und selbst dann ist es schon stressig).

Wie vermeiden: Immer Bedingungen in UPDATE- und DELETE-Queries einbauen, damit du genau bestimmst, welche Zeilen du ändern oder löschen willst.

-- So macht man's richtig:
UPDATE students
SET status = 'absolviert'
WHERE year_of_study = 4;

DELETE FROM students
WHERE status = 'ausgeschlossen';

Noch ein Trick: Vor dem Löschen immer erst ein SELECT laufen lassen, um zu checken, ob die Bedingung passt:

-- Erstmal prüfen:
SELECT * FROM students WHERE status = 'ausgeschlossen';

-- Dann löschen:
DELETE FROM students WHERE status = 'ausgeschlossen';

Fehler Nr. 2: Verletzung der Einzigartigkeit (UNIQUE)

Wenn auf einer Tabelle ein UNIQUE-Constraint liegt, führt der Versuch, ein Duplikat einzufügen, zu einem Fehler.

-- Fehler wegen doppelter Email:
INSERT INTO students (name, email) VALUES ('Otto Lin', 'otto.lin@email.com');
INSERT INTO students (name, email) VALUES ('Peter Pen', 'otto.lin@email.com');

Fehlermeldung:

ERROR: duplicate key value violates unique constraint "students_email_key"

Wie vermeiden: Vor dem Einfügen checken, ob es schon eine Zeile mit denselben Werten gibt.

-- Eine Möglichkeit:
SELECT * FROM students WHERE email = 'otto.lin@email.com';

-- Oder gleich UPSERT nutzen:
INSERT INTO students (name, email)
VALUES ('Peter Pen', 'otto.lin@email.com')
ON CONFLICT (email) DO NOTHING;

Fehler Nr. 3: Verletzung von Integritätsregeln (FOREIGN KEY)

Angenommen, du hast zwei Tabellen: students und enrollments, wobei student_id in enrollments als Foreign Key auf id in students verweist. Versuchst du, einen Eintrag in enrollments mit einer student_id einzufügen, die es in students nicht gibt, gibt's einen Fehler.

INSERT INTO enrollments (student_id, course_id)
VALUES (999, 101); -- Fehler, weil student_id 999 nicht existiert

Wie vermeiden?

1. Immer vorher checken, ob der Eintrag in der Parent-Tabelle existiert, bevor du in die verknüpfte Tabelle schreibst:

SELECT * FROM students WHERE id = 999;

2. Nutze das ON DELETE CASCADE-Constraint, damit verknüpfte Einträge automatisch gelöscht werden, wenn der Parent gelöscht wird (aber vorsichtig damit!).

CREATE TABLE enrollments (
    id SERIAL PRIMARY KEY,
    student_id INT REFERENCES students(id) ON DELETE CASCADE,
    course_id INT
);

Fehler Nr. 4: Falsche Datentypen

Beim Einfügen oder Updaten prüft PostgreSQL streng, ob die Datentypen passen. Versuchst du, einen String in ein Zahlenfeld zu schreiben, gibt's einen Fehler.

-- Fehler wegen falschem Typ:
INSERT INTO students (id, name) VALUES ('abc', 'Alex Go');

Fehlermeldung:

ERROR: invalid input syntax for type integer

Wie vermeiden? Achte auf die Datentypen der Werte, die du einfügst. Kommen die Daten aus einem User-Formular, immer im Code validieren!

Fehler Nr. 5: Probleme mit parallelem Zugriff (Datenleck)

Stell dir vor, zwei User versuchen gleichzeitig, denselben Datensatz zu updaten. Ohne vernünftige Transaktionsisolation gibt's schnell Konflikte.

-- User A:
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;

-- User B:
BEGIN;
UPDATE accounts SET balance = balance - 50 WHERE id = 1;

Wie vermeiden? Nutze Transaktionen und passende Isolationslevel, damit Daten nicht gleichzeitig geändert werden können.

BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
COMMIT;

Fehler Nr. 6: Datenverlust durch TRUNCATE

TRUNCATE löscht alle Zeilen aus einer Tabelle unwiderruflich – für diesen Befehl gibt's kein ROLLBACK (es werden keine Trigger ausgelöst und es geht blitzschnell).

-- Löscht alles für immer:
TRUNCATE TABLE students;

Wie vermeiden: Nutze lieber DELETE mit einer Bedingung statt TRUNCATE, wenn du die Möglichkeit zum Rückgängig machen behalten willst.

BEGIN;
DELETE FROM students WHERE year_of_study = 1;
-- Falls du es dir anders überlegst:
ROLLBACK;

Fehler Nr. 7: Keine Transaktionen bei wichtigen Operationen

Wenn du eine komplexe Operation mit mehreren Schritten machst und mittendrin ein Fehler passiert, können die Daten inkonsistent werden.

-- Schritt 1: Student hinzufügen
INSERT INTO students (name, email) VALUES ('Otto Lin', 'otto.lin@email.com');

-- Schritt 2: Für Kurs einschreiben
INSERT INTO enrollments (student_id, course_id) VALUES (LASTVAL(), 101); -- Fehler

Wie vermeiden? Pack solche Aktionen in eine Transaktion:

BEGIN;

INSERT INTO students (name, email) VALUES ('Max Mustermann', 'max.mustermann@email.com');
INSERT INTO enrollments (student_id, course_id) VALUES (LASTVAL(), 101);

COMMIT;

Wenn irgendwo ein Fehler auftritt, kannst du alles zurückrollen:

ROLLBACK;

Fehler Nr. 8: Zufälliger Umgang mit NULL

NULL sorgt oft für Überraschungen, weil es weder null noch ein leerer String ist – Vergleiche damit liefern manchmal unerwartete Ergebnisse.

-- Das klappt nicht:
SELECT * FROM students WHERE email = NULL;

Wie vermeiden? Nutze IS NULL oder IS NOT NULL:

SELECT * FROM students WHERE email IS NULL;

Typische Fehler passieren jedem, aber wenn du weißt, wie du sie erkennst und vermeidest, kannst du mit Daten sicher und effizient arbeiten. PostgreSQL ist ein strenger, aber fairer Wächter deiner Daten und gibt dir immer eine Fehlermeldung, wenn was schief läuft. Denk dran: Fehler sind keine Feinde, sondern Lehrer.