Einführung in Kontrollstrukturen: IF, CASE, RETURN

Kontrollstrukturen sind das Fundament von jedem Programm – egal ob SQL-Skript, Python-Code oder ein Mars-Roboter, der überlegt, ob er ein Signal nach Hause schickt oder lieber hinter dem Kraterrand nach Leben sucht.

In PL/pgSQL helfen uns Kontrollstrukturen dabei:

• Bestimmte Aktionen auszuführen, wenn Bedingungen erfüllt sind.
• Die Reihenfolge der Codeausführung zu steuern.
• Entscheidungslogik umzusetzen.

Du kannst sie dir wie Verkehrsschilder vorstellen: "Wenn du STOP siehst, bleib stehen. Wenn du grünes Licht siehst – fahr los!"

Die beliebtesten Kontrollstrukturen in PL/pgSQL:

• IF – prüft eine Bedingung und führt die passenden Befehle aus.
• CASE – eine Alternative zu IF, wenn es viele Bedingungen gibt.
• RETURN – beendet die Funktion und gibt ein Ergebnis zurück.

Du hast bestimmt schon mal davon gehört. Und nach anderen Programmiersprachen wirst du damit easy klarkommen.

Der bedingte Operator IF

Der IF-Operator wird benutzt, um Code nur dann auszuführen, wenn eine bestimmte Bedingung TRUE (wahr) ist. Hier ist die Grundstruktur:

IF bedingung THEN
  -- Code, der ausgeführt wird, wenn die Bedingung wahr ist.
ELSE
  -- Alternativer Code, wenn die Bedingung falsch ist.
END IF;

Schreiben wir eine Funktion, die eine Zahl nimmt und zurückgibt, ob sie gerade oder ungerade ist:

CREATE OR REPLACE FUNCTION check_even_odd(num INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF num % 2 = 0 THEN
    RETURN 'Zahl ist gerade';
  ELSE
    RETURN 'Zahl ist ungerade';
  END IF;
END;
$$ LANGUAGE plpgsql;

Jetzt testen wir sie:

SELECT check_even_odd(4); -- Zahl ist gerade
SELECT check_even_odd(7); -- Zahl ist ungerade

Kurz erklärt: IF num % 2 = 0 THEN prüft, ob die Zahl ohne Rest durch 2 teilbar ist.

Die ELSIF-Bedingung

Manchmal reicht eine Prüfung nicht, und du willst mehrere Bedingungen checken. Dafür gibt es ELSIF.

Stell dir vor, wir haben eine Funktion, die einen Text-Kommentar zur Temperatur zurückgibt:

CREATE OR REPLACE FUNCTION temperature_comment(temp INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF temp < 0 THEN
    RETURN 'Sehr kalt!';
  ELSIF temp >= 0 AND temp <= 20 THEN
    RETURN 'Kühl';
  ELSE
    RETURN 'Warm!';
  END IF;
END;
$$ LANGUAGE plpgsql;

Testen wir das:

SELECT temperature_comment(-5);  -- Sehr kalt!
SELECT temperature_comment(15);  -- Kühl
SELECT temperature_comment(25);  -- Warm!

Syntax von CASE

Wenn du viele Bedingungen hast, ist der CASE-Operator dein Retter. Er ist ein bisschen wie IF, aber irgendwie "eleganter".

CASE
  WHEN bedingung_1 THEN wert_1
  WHEN bedingung_2 THEN wert_2
  ELSE standardwert
END;

Wir bauen eine Funktion, die eine Textbewertung basierend auf einer Zahl zurückgibt:

CREATE OR REPLACE FUNCTION grade_comment(score INTEGER)
RETURNS TEXT AS $$
BEGIN
  RETURN CASE
    WHEN score >= 90 THEN 'Ausgezeichnet'
    WHEN score >= 75 THEN 'Gut'
    WHEN score >= 50 THEN 'Befriedigend'
    ELSE 'Nicht bestanden'
  END;
END;
$$ LANGUAGE plpgsql;

Testen wir das:

SELECT grade_comment(95); -- Ausgezeichnet
SELECT grade_comment(80); -- Gut
SELECT grade_comment(45); -- Nicht bestanden

Hinweis: Im Gegensatz zu IF gibt CASE direkt einen Wert zurück, deshalb kann man RETURN direkt im CASE benutzen.

Der RETURN-Operator

RETURN beendet die Ausführung einer Funktion und gibt einen Wert zurück. Das ist superwichtig für Funktionen in PL/pgSQL, die immer etwas zurückgeben müssen (zum Beispiel Text, Zahl usw.).

Schauen wir uns RETURN an einem einfachen Beispiel an:

CREATE OR REPLACE FUNCTION return_example()
RETURNS TEXT AS $$
BEGIN
  RETURN 'Hallo, Welt!';
END;
$$ LANGUAGE plpgsql;

Das Ergebnis:

SELECT return_example(); -- Hallo, Welt!

Aber was, wenn wir mehrere Codezweige haben? Zum Beispiel eine Prüfung der Eingabedaten. Dann wird RETURN an verschiedenen Stellen in der Funktion benutzt:

CREATE OR REPLACE FUNCTION check_positive_negative(num INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF num > 0 THEN
    RETURN 'Positive Zahl';
  ELSIF num = 0 THEN
    RETURN 'Null';
  ELSE
    RETURN 'Negative Zahl';
  END IF;
END;
$$ LANGUAGE plpgsql;

Testen wir das:

SELECT check_positive_negative(10); -- Positive Zahl
SELECT check_positive_negative(0);  -- Null
SELECT check_positive_negative(-5); -- Negative Zahl

Typische Fehler und wo man durcheinander kommen kann

1. Vergessen des END-Operators: Vergisst du END CASE; oder END IF;, erinnert dich PostgreSQL sofort daran, dass du den Codeblock abschließen musst.
2. Logikfehler bei ELSIF: Die Reihenfolge der Bedingungen ist wichtig! Eine allgemeinere Bedingung (temp > 0) sollte nicht vor einer spezielleren (temp > 20) stehen.
3. RETURN vergessen: In PL/pgSQL muss eine Funktion immer etwas zurückgeben, wenn du RETURNS angegeben hast.

Das war's erstmal. Wir haben die Grundlagen von Kontrollstrukturen und Logik in PL/pgSQL angeschaut. Dieses Wissen brauchst du später, wenn du komplexere Funktionen baust! Beim nächsten Mal schauen wir uns Schleifen und deren Einsatz an.