PL/pgSQL-Debugging mit pgAdmin: Breakpoints, Variablen anschauen

Also, du hast deine erste Prozedur oder Funktion geschrieben, sie ausgeführt, aber irgendwas läuft schief. Klar, du könntest jetzt überall RAISE NOTICE einbauen, um rauszufinden, wo genau das "Schiff auf Grund gelaufen ist". Aber! Warum sich quälen, wenn pgAdmin schon einen eingebauten Debugger hat?

pgAdmin gibt dir die Möglichkeit, deinen Code Schritt für Schritt auszuführen, Breakpoints zu setzen, Variablenwerte zu checken und Fehlerursachen zu finden. Das ist quasi dein "Detektiv-Set", um das Rätsel zu lösen: "Warum läuft mein Query nicht?"

Warum Debugging mit pgAdmin?

Manchmal sind Bugs in Prozeduren so tief versteckt, dass du mit Logs oder Terminal-Texten einfach nicht weiterkommst. Genau hier hilft dir das Step-by-Step-Debugging, weil du alles siehst, was bei jedem Schritt in der Funktion passiert. Stell dir vor, das ist wie ein mega kompliziertes Puzzle – aber mit Tipps.

Mit Debugging in pgAdmin kannst du:

1. Breakpoints setzen – das sind Stellen, wo der Code anhält, damit du den aktuellen Zustand analysieren kannst.
2. Schritt für Schritt durch den SQL-Code gehen – wirklich Zeile für Zeile sehen, welcher Befehl gerade läuft.
3. Variablenwerte in Echtzeit anschauen – checken, ob die Daten korrekt übergeben und verarbeitet werden.
4. Die Stelle finden, wo der Fehler passiert ist, und den Grund verstehen.

Loslegen: Vorbereitung fürs Debugging in pgAdmin

Bevor du mit dem Debugging startest, lass uns kurz checken, ob alles richtig eingerichtet ist.

Das plpgsql-Extension aktivieren

Stell sicher, dass in deiner Datenbank die Programmiersprache PL/pgSQL aktiviert ist:

CREATE EXTENSION IF NOT EXISTS plpgsql;

Diese Sprache ist normalerweise in PostgreSQL schon standardmäßig aktiviert, aber besser nochmal prüfen.

Stell sicher, dass du pgAdmin in Version 4 oder höher installiert hast (nur dann geht Debugging). Falls du es noch nicht hast, kannst du pgAdmin von der offiziellen Seite runterladen.

Das pldbgapi-Extension installieren

Damit du PL/pgSQL in pgAdmin debuggen kannst, musst du das Extension pldbgapi aktivieren:

CREATE EXTENSION IF NOT EXISTS pldbgapi;

Dieses Extension ist extra für die Zusammenarbeit mit dem Debugger gebaut.

Ganz wichtig!!! Du brauchst Admin-Rechte auf dem PostgreSQL-Server, um diesen Befehl auszuführen.

Debugging-Basics: Breakpoints setzen

Breakpoints sind spezielle Stellen im Code, wo die Ausführung der Prozedur oder Funktion anhält, damit du reinschauen kannst, was gerade abgeht. Das ist wie eine kurze Pause auf einer langen Reise: anhalten, umschauen, Karte checken, und dann weiterfahren.

Wie setzt man einen Breakpoint in pgAdmin?

1. Öffne pgAdmin und verbinde dich mit deiner Datenbank.
2. Such deine Funktion oder Prozedur im Objektbaum: Functions → <dein Schema> → <deine Funktion>.
3. Klick mit rechts auf die Funktion und wähle Debugging → Debug. Damit startest du den Debugger.
4. Im Fenster mit dem Funktionscode such die Zeile, wo du das Debugging starten willst, und klick links neben die Zeile. Du siehst dann einen roten Kreis – das ist der Breakpoint.

So sieht das aus:

CREATE OR REPLACE FUNCTION example_function(id INTEGER)
RETURNS VOID AS $$
BEGIN
    RAISE NOTICE 'Du hast id gewählt: %', id;
    -- Hier kannst du einen Breakpoint setzen
    PERFORM some_operation(id);
END;
$$ LANGUAGE plpgsql;

Nachdem du den Breakpoint gesetzt hast, kannst du die Funktion ausführen und die Ausführung stoppt genau an dieser Stelle. Jetzt kannst du Variablenwerte checken, die Ergebnisse der vorherigen Befehle anschauen und natürlich den Code weiter ausführen.

Variablen in pgAdmin anschauen

Zu wissen, dass dein Code gestoppt hat, ist cool. Aber noch besser ist es, zu verstehen, welche Daten gerade im Speicher sind. Zum Beispiel:

• Welche Werte haben die Eingabeparameter?
• Wie haben sich Variablen nach einem bestimmten Block verändert?
• Was hat die Query aus der Datenbank zurückgegeben?

Wie schaut man Variablenwerte an?

Wenn die Funktion an einem Breakpoint gestoppt hat:

1. Geh unten im Debugger-Fenster auf den Tab Variables.
2. Hier siehst du alle Variablen und ihre aktuellen Werte.

Angenommen, wir haben diese Funktion:

CREATE OR REPLACE FUNCTION calculate_discount(price NUMERIC, discount NUMERIC)
RETURNS NUMERIC AS $$
DECLARE
    discounted_price NUMERIC;
BEGIN
    discounted_price := price - (price * discount / 100);
    RETURN discounted_price;
END;
$$ LANGUAGE plpgsql;

Wenn du einen Breakpoint auf die Zeile mit discounted_price setzt, zeigt dir der Debugger, dass die Variablen price und discount schon Werte haben, aber discounted_price ist noch leer.

So sieht die Variablenliste nach dem Stopp aus:

Nachdem du die aktuelle Zeile ausgeführt hast, ändert sich discounted_price auf 85.00.

Code Schritt für Schritt ausführen

Im Debugger-Fenster kannst du die Ausführung deiner Funktion mit Buttons steuern:

1. Step Over – führt die aktuelle Zeile aus und geht zur nächsten.
2. Step Into – damit kannst du in eine aufgerufene Funktion oder Prozedur "reinspringen".
3. Continue – führt die Funktion bis zum nächsten Breakpoint oder bis zum Ende aus.

Praxis: Komplexe Funktionen debuggen

Lass uns mal eine etwas komplexere Funktion schreiben und debuggen.

Beispiel: Bestellungen verarbeiten

CREATE OR REPLACE FUNCTION process_order(order_id INTEGER)
RETURNS TEXT AS $$
DECLARE
    order_status TEXT;
    total_amount NUMERIC;
BEGIN
    -- Bestellstatus setzen
    SELECT status INTO order_status
    FROM orders
    WHERE id = order_id;

    IF order_status = 'Pending' THEN
        -- Bestellsumme berechnen
        SELECT SUM(price * quantity) INTO total_amount
        FROM order_items
        WHERE order_id = order_id;

        -- Bestellstatus aktualisieren
        UPDATE orders
        SET status = 'Processed', processed_date = NOW()
        WHERE id = order_id;

        RETURN 'Bestellung verarbeitet. Summe: ' || total_amount;
    ELSE
        RETURN 'Bestellung wurde schon verarbeitet oder existiert nicht.';
    END IF;
END;
$$ LANGUAGE plpgsql;

Mögliche Breakpoints:

1. In der Zeile SELECT status INTO order_status.
2. In der Zeile SELECT SUM(price * quantity) INTO total_amount.

Beim Debuggen kannst du:

• Checken, ob order_status wirklich 'Pending' ist.
• Prüfen, ob total_amount korrekt berechnet wird.

Typische Fehler und wie du sie löst

Beim Debuggen mit pgAdmin können dir folgende Situationen begegnen:

1. Du siehst deine Funktion nicht in der Liste. Check, ob die Funktion wirklich in deiner Datenbank existiert und ob du mit der richtigen DB verbunden bist.

2. Breakpoints funktionieren nicht. Check, ob das pldbgapi-Extension aktiviert ist und ob du die nötigen Rechte hast.

3. Fehler beim Verbinden des Debuggers. Stell sicher, dass der PostgreSQL-Server fürs Debugging konfiguriert ist (Parameter shared_preload_libraries enthält pldbgapi).

Mit pgAdmin wird das Debuggen von PL/pgSQL richtig easy und intuitiv. Setz einen Breakpoint, schau, was deine Variablen machen, und fix alle Bugs – das ist schon der halbe Weg zu deiner perfekten App!