PL/pgSQL Syntax-Grundlagen

Lass uns tiefer in PL/pgSQL eintauchen und anfangen, es aktiver zu nutzen.

Code-Block

Ein Code-Block in PL/pgSQL ist das grundlegende Bauelement der Sprache. Man kann sagen, das ist das Gerüst, auf dem unsere Funktionen, Prozeduren und der ganze Zauber aufbauen. Der Block sorgt für die Ausführung der Logik, Datenverarbeitung, Fehlerbehandlung – alles in einem "Container".

PL/pgSQL-Blöcke sind strukturiert und bestehen aus drei Hauptteilen:

1. DECLARE: Variablen deklarieren (optional).
2. BEGIN ... END: Hauptausführungsblock, wo die Logik passiert.
3. EXCEPTION: Fehlerbehandlung (optional).

Für alle, die Analogien mögen: Stell dir ein Kochrezept vor. Auch wenn das Rezept mit einer Zutatenliste beginnt, passiert die eigentliche Magie beim Kochen selbst. Im PL/pgSQL-Sprech:

• DECLARE – das ist die Zutatenliste (Variablen).
• BEGIN ... END – hier wird gemischt, gebraten und gekocht.
• EXCEPTION – das ist der Notfallplan, falls was anbrennt.

PL/pgSQL Block-Syntax

Schauen wir uns zuerst die allgemeine Struktur eines Blocks an, quasi das "Skelett". Später fügen wir Fleisch (oder veganen Käse, wenn du magst) – also die eigentliche Logik – hinzu.

DO $$
DECLARE
    -- Hier werden Variablen deklariert
    student_count INT;
BEGIN
    -- Hier läuft die Logik
    SELECT COUNT(*) INTO student_count FROM students;
    RAISE NOTICE 'Gesamtanzahl der Studenten: %', student_count;
EXCEPTION
    -- Hier werden Fehler behandelt
    WHEN OTHERS THEN
        RAISE NOTICE 'Ein Fehler ist aufgetreten.';
END;
$$;

Lass uns das Schritt für Schritt durchgehen.

1. DECLARE – hier deklarieren wir unsere Variablen. Das Coole ist, dass PL/pgSQL fast alle Datentypen von PostgreSQL unterstützt – von einfachen INTEGER bis zu exotischen JSONB. Um eine Variable zu deklarieren, gibst du ihren Namen, den Datentyp und falls nötig einen Startwert an.

Beispiel:

DECLARE
    student_name TEXT;    -- Variable für den Namen des Studenten
    course_count INT := 0; -- Startwert auf 0 setzen
    is_graduated BOOLEAN; -- Boolesche Variable

Beachte, dass Variablen mit oder ohne Initialisierung sein können (wie course_count).

2. BEGIN ... END – Hauptausführungsblock.

Dieser Teil des Blocks ist für die Hauptlogik zuständig. Hier kannst du:

• SQL-Queries ausführen (SELECT, INSERT, usw.).
• Daten manipulieren.
• Kontrollstrukturen verwenden (IF, LOOP, usw.).
• Debug-Nachrichten mit RAISE ausgeben.

Beispiel:

BEGIN
    SELECT COUNT(*) INTO student_count FROM students;
    IF student_count > 0 THEN
        RAISE NOTICE 'Wir haben Studenten!';
    ELSE
        RAISE NOTICE 'Keine Studenten gefunden.';
    END IF;
END;

3. EXCEPTION – Fehlerbehandlung (optional).

Wenn beim Ausführen des Blocks ein Fehler auftritt, kannst du mit der EXCEPTION-Sektion den Fehler abfangen und etwas Sinnvolles tun – zum Beispiel eine Nachricht ausgeben oder alternativen Code ausführen.

Beispiel:

BEGIN
    SELECT COUNT(*) INTO student_count FROM non_existing_table; -- Fehler!
EXCEPTION
    WHEN OTHERS THEN
        RAISE NOTICE 'Ups, da ist was schiefgelaufen!';
END;

Praxisbeispiel: Studenten zählen

Jetzt bauen wir alles zusammen in ein Beispiel, das du im echten Leben brauchen könntest. Wir schreiben einen PL/pgSQL-Block, der die Anzahl der Studenten in der Tabelle students zählt und eine Nachricht ausgibt.

DO $$
DECLARE
    total_students INT; -- Variable für die Anzahl der Studenten
BEGIN
    -- Studentenanzahl zählen
    SELECT COUNT(*) INTO total_students FROM students;

    -- Nachricht mit dem Ergebnis ausgeben
    RAISE NOTICE 'Anzahl der Studenten: %', total_students;
EXCEPTION
    -- Mögliche Fehler behandeln, z.B. wenn die Tabelle nicht existiert
    WHEN OTHERS THEN
        RAISE NOTICE 'Beim Zählen der Studenten ist ein Fehler aufgetreten.';
END;
$$;

Wenn du diesen Block aufrufst, bekommst du eine Nachricht in der Konsole. Zum Beispiel: Anzahl der Studenten: 42.

Besonderheiten bei Variablen

Lass uns ein paar wichtige Punkte anschauen:

Werte zuweisen. Um Daten in eine Variable zu schreiben, kannst du SELECT INTO verwenden:

SELECT COUNT(*) INTO total_students FROM students;

Initialisierung von Variablen. Wenn du einer Variable beim Deklarieren keinen Wert gibst, ist ihr Standardwert NULL.

Zum Beispiel:

DECLARE
    my_var INT; -- Wert ist NULL

Variablen vom Typ RECORD. Das ist ein universeller Variablentyp, in den du Zeilen aus einer Tabelle speichern kannst. Beispiel:

DECLARE
    student RECORD;
BEGIN
    SELECT * INTO student FROM students WHERE id = 1;
    RAISE NOTICE 'Studentenname: %, Alter: %', student.name, student.age;
END;

Beispiel: Kurse für einen Studenten zählen

Jetzt lösen wir eine praktische Aufgabe: Wir zählen, wie viele Kurse ein Student belegt hat, und geben das Ergebnis aus.

DO $$
DECLARE
    student_id INT := 1;   -- Studenten-ID
    course_count INT;      -- Variable für die Anzahl der Kurse
BEGIN
    -- Anzahl der Kurse zählen
    SELECT COUNT(*) INTO course_count
    FROM enrollments
    WHERE student_id = student_id;

    -- Nachricht ausgeben
    RAISE NOTICE 'Student ID % ist in % Kursen eingeschrieben.', student_id, course_count;
EXCEPTION
    WHEN OTHERS THEN
        RAISE NOTICE 'Beim Verarbeiten der Studenten-ID % ist ein Fehler aufgetreten', student_id;
END;
$$;

Dieser Block ist flexibel: Du kannst student_id ändern, um zu prüfen, wie viele Kurse verschiedene Studenten belegt haben.

Fehler und wie man sie vermeidet

Wenn PL/pgSQL in dir schon wie ein kleiner Hotdog in der Mikrowelle zappelt, ist das ganz normal. Am Anfang stolpert man oft über "typische" Fehler. Hier ein paar Beispiele:

Variable nicht deklariert. Wenn du vergisst, eine Variable mit DECLARE zu deklarieren, gibt PL/pgSQL einen Fehler aus, dass die Variable "nicht existiert".

Versuch, NULL als Wert zu verwenden. Wenn eine Variable deklariert, aber nicht initialisiert wurde, ist ihr Wert NULL. Das kann zu unerwartetem Verhalten führen. Zum Beispiel:

IF my_var = NULL THEN -- Funktioniert NICHT!

Benutze IS NULL:

IF my_var IS NULL THEN

Falsche Nutzung der EXCEPTION-Sektion. Manche Entwickler fangen alle Fehler ab (WHEN OTHERS), schreiben aber nicht, was passieren soll. Das kann echte Probleme verstecken. Besser ist es, eine Fehlermeldung auszugeben:

RAISE NOTICE 'Fehler: %', SQLERRM;