Fehlerbehandlung beim Einfügen und Aktualisieren von Daten

Lass uns typische Fehler anschauen, die beim Einfügen neuer Daten in eine Tabelle passieren können.

Fehler 1: Versuch, NULL in ein Pflichtfeld einzufügen

PostgreSQL achtet streng darauf, dass die Regeln der Datenbank eingehalten werden. Hier ein paar Beispiele für Constraints, die zu Fehlerquellen werden können:

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL, -- Name darf nicht NULL sein
    age INT
);

-- Fehler: Feld name muss ausgefüllt werden
INSERT INTO students (name, age) VALUES (NULL, 20);

Ergebnis: Fehler null value in column "name" of relation "students" violates not-null constraint`.

Du musst darauf achten, welche Daten du einfügst. Vielleicht war diese Spalte früher mal NULL erlaubt, aber jetzt ist sie Pflichtfeld.

Fehler 2: Duplikate in einer Unique-Spalte.

CREATE TABLE courses (
    course_id SERIAL PRIMARY KEY,
    course_name TEXT UNIQUE -- Kursname muss eindeutig sein
);

-- Erster Insert klappt
INSERT INTO courses (course_name) VALUES ('SQL Basics');

-- Zweiter Insert verursacht Fehler
INSERT INTO courses (course_name) VALUES ('SQL Basics');

Ergebnis: Fehler duplicate key value violates unique constraint`.

Meistens ist das nicht dein Fehler, sondern der User versucht aus Versehen, etwas doppelt zu machen. In dem Fall musst du eigentlich nichts tun.

Fehler 3: Verletzung der referenziellen Integrität.

CREATE TABLE enrollments (
    enrollment_id SERIAL PRIMARY KEY,
    student_id INT REFERENCES students(id), -- Es muss einen Studenten mit dieser ID geben
    course_id INT REFERENCES courses(course_id)
);

-- Fehler: Student mit ID = 99 existiert nicht
INSERT INTO enrollments (student_id, course_id) VALUES (99, 1);

Ergebnis: Fehler insert or update on table "enrollments" violates foreign key constraint`.

Eigentlich ist es super, dass hier ein Fehler kommt. Nichts ist schlimmer als eine kaputte Datenbank-Integrität. Wahrscheinlich gibt es einen Bug im Code, der mit der DB arbeitet, oder die Daten sind veraltet. Auf jeden Fall: Wenn die Datenbank ihre Integrität schützt – Daumen hoch!

Fehlerbehandlung in PostgreSQL

Klar, Fehler passieren. Aber wichtig ist, dass du nicht nur sie bemerkst, sondern auch damit umgehen kannst.

Transaktionen als Schutzmechanismus

Wenn wir mit Daten arbeiten, nutzen wir oft Transaktionen, um Konsistenz zu garantieren. Wenn ein Fehler auftritt, können wir alles zurückrollen.

Beispiel: Daten in zwei Tabellen einfügen.

BEGIN; -- Transaktion starten

-- Daten in students einfügen
INSERT INTO students (name, age) VALUES ('Otto Lin', 21);

-- Eintrag in enrollments einfügen
-- Hier gibt's einen Fehler, falls Kurs mit ID=10 nicht existiert
INSERT INTO enrollments (student_id, course_id) VALUES (1, 10);

-- Wenn alles geklappt hat
COMMIT;
-- Bei Fehler alles zurückrollen
ROLLBACK;

Wenn der Kurs mit course_id = 10 nicht existiert, wird auch das Insert in die Tabelle students rückgängig gemacht.

Fehlerbehandlung in Transaktionen

In PostgreSQL kannst du Fehler vorhersehen und direkt im Query mit EXCEPTION-Blöcken abfangen.

Beispiel: Wir fügen einen Studenten hinzu und schreiben ihn in einen Kurs ein. Wenn ein Fehler passiert, landet der Fehler im Log.

DO $$
BEGIN
    -- Versuch, Daten einzufügen
    INSERT INTO students (name, age) VALUES ('Anna Song', 22);
    INSERT INTO enrollments (student_id, course_id) VALUES (2, 999); -- Fehler

    -- Wenn alles klappt
    RAISE NOTICE 'Eintrag erfolgreich hinzugefügt!';
EXCEPTION
    WHEN foreign_key_violation THEN
        -- Fremdschlüsselverletzung behandeln
        RAISE WARNING 'Kurs mit angegebenem course_id existiert nicht.';
END $$;

Einzigartigkeit prüfen mit ON CONFLICT

Du kannst Fehler wegen UNIQUE-Constraint schon vorher verhindern, indem du ON CONFLICT benutzt. Damit kannst du sagen, was bei einem Konflikt passieren soll.

Beispiel: Wenn wir versuchen, einen doppelten Kurs einzufügen, überspringen wir das Insert einfach.

INSERT INTO courses (course_name)
    VALUES ('SQL Basics')
ON CONFLICT (course_name) DO NOTHING; -- Doppelte Daten überspringen

Oder wir aktualisieren die bestehende Zeile:

INSERT INTO courses (course_name)
    VALUES ('SQL Basics')
ON CONFLICT (course_name) DO UPDATE     
    SET course_name = EXCLUDED.course_name || ' (Updated)';

Mehr zum ON CONFLICT-Operator gibt's im nächsten Level, wenn wir uns Bulk-Loading anschauen :P

Typische Fehler im Umgang mit Daten und wie du sie verhinderst

Du hast schon gesehen, die Hauptquellen für Fehler sind:

1. Verletzung von Constraints (NOT NULL, UNIQUE, FOREIGN KEY).
2. Fehlende Bedingungen im Query (WHERE) beim Update oder Delete.
3. Fehler in der Reihenfolge von Transaktionen.

So schützt du dich davor:

• Nutze Transaktionen und ROLLBACK für große Aktionen.
• Check immer die Daten, bevor du sie einfügst.
• Logge Fehler zum Analysieren.
• Setze ON CONFLICT ein, um doppelte Einträge zu vermeiden.

Jetzt bist du bereit, Fehler zu bekämpfen! Denk dran: Ein guter Entwickler ist nicht der, der keine Fehler macht, sondern der, der sie fixen kann.