Logging mit RAISE NOTICE

Logging ist der Prozess, bei dem wichtige Events und Infos über die Arbeit einer App oder Datenbank aufgezeichnet werden. In PL/pgSQL ist das besonders praktisch, wenn du komplexe Funktionen schreibst, die andere Funktionen aufrufen, mit Triggern arbeiten oder viele Schritte ausführen. Hier sind ein paar wichtige Gründe, warum Logging so wichtig ist:

1. Code-Debugging: Logging hilft dir zu checken, was genau in jedem Schritt deiner Funktion passiert.
2. Fehlerdiagnose: Wenn eine Funktion nicht so läuft wie erwartet, helfen dir die Logs dabei, genau zu finden, wo der Fehler auftritt.
3. Ablauf-Analyse: Wenn du weißt, welche Schritte (und in welcher Reihenfolge) ausgeführt wurden, kannst du die Performance optimieren oder Verbesserungsmöglichkeiten finden.
4. Wartungsfreundlichkeit: Stell dir vor, du schaust dir deine Funktion in einem Jahr nochmal an und verstehst gar nichts mehr (glaub mir, das passiert). Logs retten dich in solchen Situationen.

RAISE NOTICE – das Logging-Basis-Tool

Wenn du schon mal print() oder console.log() zum Debuggen genutzt hast, dann ist RAISE NOTICE quasi der große Bruder davon in der PostgreSQL-Welt. Das ist ein Befehl, der Info-Messages während der Ausführung einer Funktion ausgibt. Diese Nachrichten siehst du in der Konsole, im Terminal oder im Interface, wo dein Query läuft.

Syntax von RAISE NOTICE

RAISE NOTICE 'Ausführungsnachricht';

Aber das ist erst der Anfang. Du kannst Variablen in deine Messages einbauen, damit sie noch informativer werden:

RAISE NOTICE 'Aktueller Wert der Variable: %', my_variable;

Hier ist % ein Platzhalter und my_variable ist die Variable, deren Wert du anzeigen willst.

Wenn du mehrere Variablen ausgeben willst, geht das so:

RAISE NOTICE 'Werte: % und %', var1, var2;

Beispiele für RAISE NOTICE-Einsatz

1. Variablenwert ausgeben. Wir deklarieren eine Variable in der Funktion und geben ihren Wert mit RAISE NOTICE aus.

CREATE OR REPLACE FUNCTION debug_variable_example()
RETURNS VOID AS $$
DECLARE
    my_variable INTEGER := 42;
BEGIN
    RAISE NOTICE 'Wert der Variable my_variable: %', my_variable;
END;
$$ LANGUAGE plpgsql;

Wenn du diese Funktion aufrufst:

SELECT debug_variable_example();

Siehst du im Ergebnis sowas wie:

NOTICE:  Wert der Variable my_variable: 42

2. Logging der Ausführungsschritte. Stell dir vor, du hast eine Funktion, die mehrere Schritte machen soll. Du kannst nach jedem Schritt ein RAISE NOTICE einbauen, um zu checken, ob alles läuft wie geplant.

CREATE OR REPLACE FUNCTION process_data()
RETURNS VOID AS $$
BEGIN
    RAISE NOTICE 'Schritt 1: Prozessstart';

    -- Hier läuft irgendein SQL-Code
    PERFORM pg_sleep(1); -- Operation simulieren

    RAISE NOTICE 'Schritt 2: Prozess läuft weiter';

    -- Noch mehr SQL
    PERFORM pg_sleep(1); -- Operation simulieren

    RAISE NOTICE 'Schritt 3: Prozess abgeschlossen';
END;
$$ LANGUAGE plpgsql;

Wenn du die Funktion aufrufst:

SELECT process_data();

Bekommst du:

NOTICE:  Schritt 1: Prozessstart
NOTICE:  Schritt 2: Prozess läuft weiter
NOTICE:  Schritt 3: Prozess abgeschlossen

Jetzt weißt du immer, an welchem Schritt die Ausführung gerade ist.

Praxiseinsatz

Schauen wir uns ein Beispiel für Logging bei Berechnungen an. Wir bauen eine Funktion, die die Summe der Zahlen von 1 bis N berechnet und den Prozess loggt:

CREATE OR REPLACE FUNCTION sum_with_logging(n INTEGER)
RETURNS INTEGER AS $$
DECLARE
    total INTEGER := 0;
    i INTEGER;
BEGIN
    RAISE NOTICE 'Berechnungsstart für n = %', n;

    FOR i IN 1..n LOOP
        total := total + i;
        RAISE NOTICE 'Summe bei Schritt %: %', i, total;
    END LOOP;

    RAISE NOTICE 'Berechnungsergebnis: %', total;

    RETURN total;
END;
$$ LANGUAGE plpgsql;

Wenn du die Funktion mit dem Parameter 5 aufrufst:

SELECT sum_with_logging(5);

Siehst du:

NOTICE:  Berechnungsstart für n = 5
NOTICE:  Summe bei Schritt 1: 1
NOTICE:  Summe bei Schritt 2: 3
NOTICE:  Summe bei Schritt 3: 6
NOTICE:  Summe bei Schritt 4: 10
NOTICE:  Summe bei Schritt 5: 15
NOTICE:  Berechnungsergebnis: 15

Nützliche Logging-Tipps

1. Räume unnötige Logs auf: Wenn deine Funktion fertig und getestet ist, lösch überflüssige RAISE NOTICE-Messages, damit du das Terminal oder das User-Interface nicht zumüllst.
2. Schreib sinnvolle Nachrichten: Schreib nicht einfach "Schritt 1", "Schritt 2". Mach klar, was da eigentlich passiert.
3. Sei vorsichtig mit sensiblen Daten: Schreib niemals Kreditkartendaten, Passwörter oder andere vertrauliche Infos in die Logs.

2

Aufgabe

SQL SELF, Level 52, Lektion 1

Gesperrt

Protokollierung des Werts einer Variablen

Protokollierung des Werts einer Variablen

Öffnen