Einführung ins Debugging von PL/pgSQL

Stell dir vor, du hast eine komplexe Funktion oder Prozedur gebaut. Du siehst schon, wie cool deine Datenbank läuft, aber plötzlich – zack! – die Daten stimmen nicht, die Abfragen sind langsam und dein Chef wird nervös. Genau hier kommt Debugging ins Spiel.

Debugging in PL/pgSQL brauchst du, um:

• Logikfehler zu finden, zum Beispiel wenn eine Funktion nicht das zurückgibt, was du erwartest.
• Mit fehlerhaften Eingabedaten klarzukommen. Denn manchmal geben die User der Datenbank nicht nur Daten ein, sondern auch... irgendwas total Unverständliches!
• Performance-Probleme zu beseitigen. Schnell hingeschriebener Code kann laufen wie eine Schildkröte, die in der Sahara nach WLAN sucht.

Mal im Ernst: Debugging ist nicht nur Fehler suchen und fixen. Es ist auch ein Weg, deinen Code besser, schneller und lesbarer zu machen.

Grundlegende Ansätze fürs Debugging in PL/pgSQL

Debugging in PL/pgSQL kann auf verschiedene Arten gemacht werden. Lass uns die mal der Reihe nach anschauen.

1. Verwendung von eingebauten PostgreSQL-Tools

PostgreSQL bringt ein paar eingebaute Möglichkeiten zur Diagnose mit, darunter Logging-Funktionen (RAISE NOTICE und RAISE EXCEPTION) sowie die Analyse von Ausführungsplänen (EXPLAIN ANALYZE). Diese Tools helfen dir zu verstehen, was in deiner Funktion abgeht.

2. Logging mit RAISE NOTICE

RAISE NOTICE ist dein Kumpel, wenn du wissen willst, welche Daten durch die Funktion laufen, an welcher Stelle was schiefgeht oder wie die Variablen gerade aussehen. Im Gegensatz zu RAISE EXCEPTION unterbricht er die Funktion nicht. Du kannst zum Beispiel den Inhalt einer Variablen bei jedem Schritt ausgeben lassen.

DO $$
DECLARE
    counter INT := 0;
BEGIN
    FOR counter IN 1..5 LOOP
        RAISE NOTICE 'Aktueller Wert vom Zähler: %', counter;
    END LOOP;
END $$;

Dieser Code gibt die Werte von counter von 1 bis 5 aus. Simple Magie, aber mega nützlich fürs Debugging!

3. Verwendung von externen Tools

Debugging von PL/pgSQL geht auch mit Tools wie pgAdmin (mit GUI). Damit kannst du Breakpoints setzen und Variablenwerte live anschauen. Wenn du auf visuelle Helfer stehst, ist pgAdmin dein bester Buddy.

Phasen des Debuggings

Wenn wir mit dem Debugging einer Funktion oder Prozedur starten, ist es wichtig, einer bestimmten Reihenfolge zu folgen. Schauen wir uns die einzelnen Schritte genauer an:

1. Analyse der Eingabedaten

Das Erste, was du checken solltest, sind die Eingabedaten. Stell sicher, dass die Daten, die deine Funktion bekommt, keine Fehler oder komischen Werte enthalten. Zum Beispiel kannst du alle Eingabeparameter mit RAISE NOTICE prüfen:

CREATE FUNCTION check_input(x INTEGER) RETURNS VOID AS $$
BEGIN
    IF x IS NULL THEN
        RAISE EXCEPTION 'Eingabewert darf nicht NULL sein!';
    END IF;
    RAISE NOTICE 'Eingabewert: %', x;
END;
$$ LANGUAGE plpgsql;

Dieses Beispiel zeigt, wie du User auf Probleme mit den Eingabedaten hinweist.

2. Jeden Schritt der Ausführung prüfen

Teile deine Funktion in logische Blöcke und füge RAISE NOTICE an den wichtigen Stellen ein. So findest du raus, wo genau was schiefgeht.

CREATE FUNCTION calculate_discount(price NUMERIC, discount NUMERIC) RETURNS NUMERIC AS $$
BEGIN
    RAISE NOTICE 'Funktionsstart: Preis %, Rabatt %', price, discount;

    IF price <= 0 THEN
        RAISE EXCEPTION 'Preis darf nicht negativ oder null sein!';
    END IF;

    IF discount < 0 OR discount > 100 THEN
        RAISE EXCEPTION 'Rabatt muss zwischen 0 und 100 liegen!';
    END IF;

    RETURN price - (price * discount / 100);
END;
$$ LANGUAGE plpgsql;

Hier bekommst du bei jedem Debugging-Schritt nützliche Infos zum Status des Prozesses.

3. Optimierung und Fehlerbehebung
4. Wenn du den Fehler gefunden hast, behebe ihn. Falls es ein Performance-Problem ist, nutze Analyse-Tools wie EXPLAIN ANALYZE, um deine Abfragen zu optimieren.

Praxiseinsatz von Debugging-Skills

Schauen wir uns eine echte Aufgabe an: Wir haben eine Funktion, die einen Eintrag in eine Tabelle schreibt und die generierte ID zurückgibt. Klingt logisch und einfach, aber manchmal gibt die Funktion einen Fehler zurück und wir wollen wissen, warum.

Ursprüngliche Funktion:

CREATE FUNCTION add_student(name TEXT, age INTEGER) RETURNS INTEGER AS $$
DECLARE
    new_id INTEGER;
BEGIN
    INSERT INTO students (name, age) VALUES (name, age) RETURNING id INTO new_id;
    RETURN new_id;
END;
$$ LANGUAGE plpgsql;

Wenn du diese Funktion mit falschen Daten aufrufst, zum Beispiel age < 0, gibt sie einen Fehler aus. Lass sie uns mit Debugging-Tools verbessern.

Verbesserte Funktion mit Logging:

CREATE FUNCTION add_student(name TEXT, age INTEGER) RETURNS INTEGER AS $$
DECLARE
    new_id INTEGER;
BEGIN
    -- Eingabedaten loggen
    RAISE NOTICE 'Student hinzufügen: Name %, Alter %', name, age;

    -- Alter prüfen
    IF age < 0 THEN
        RAISE EXCEPTION 'Alter darf nicht negativ sein!';
    END IF;

    -- Student hinzufügen und ID zurückgeben
    INSERT INTO students (name, age) VALUES (name, age) RETURNING id INTO new_id;

    -- Erfolgreiche Ausführung loggen
    RAISE NOTICE 'Student wurde mit ID % hinzugefügt', new_id;

    RETURN new_id;
END;
$$ LANGUAGE plpgsql;

Jetzt weißt du bei einem Fehler ganz genau, was schiefgelaufen ist – dank der Ausgaben mit RAISE NOTICE.

Nützliche Tipps zum Schluss

1. Vergiss nicht, unnötiges Logging aus dem Produktivcode zu entfernen. RAISE NOTICE ist super fürs Debugging, aber wenn du es immer drin lässt, werden die Logs im Produktivbetrieb schnell unübersichtlich.
2. Arbeite mit kleinen Code-Schnipseln. Wenn eine Funktion zu komplex ist, teile sie in mehrere Teile auf. Das macht das Debugging viel einfacher.
3. Übe regelmäßig. Je mehr du schreibst und debugged, desto schneller findest und behebst du Fehler.

Debugging ist wie Detektiv spielen – nur hast du statt einer Lupe SQL-Queries und PL/pgSQL-Logik. Meisterschaft kommt mit Erfahrung, aber jeder gefixte Bug macht dich ein bisschen besser!

2

Aufgabe

SQL SELF, Level 55, Lektion 0

Gesperrt

Eingabewert-Prüfung mit RAISE EXCEPTION und RAISE NOTICE

Eingabewert-Prüfung mit RAISE EXCEPTION und RAISE NOTICE

Öffnen