PostgreSQL CASE-Anweisung für bedingte SQL-Abfragen verwenden

Die CASE-Anweisung in PostgreSQL ermöglicht es, innerhalb einer SQL-Abfrage Bedingungen auszuwerten und abhängig davon Werte zurückzugeben. Sie eignet sich besonders, um Daten dynamisch zu klassifizieren – beispielsweise zur Notenvergabe oder Zuordnung von Labels basierend auf Schwellenwerten.

Diese Anleitung zeigt dir, wie du mit der CASE-Klausel Daten aus einer Datenbank kategorisierst. Du wirst eine Beispieldatenbank mit Tabellen für Studierende und deren Ergebnisse erstellen und anschließend mit der CASE-Anweisung Noten aus Punktzahlen berechnen.

Voraussetzungen

Bevor du loslegst, stelle sicher, dass du folgendes eingerichtet hast:

• Eine laufende PostgreSQL-Instanz mit Zugangsdaten
• Ein Linux-System als Client
• SSH-Zugang zum Server
• Einen Benutzer mit sudo-Rechten (kein Root)
• Installierten psql-Client

Funktionsweise der CASE-Anweisung in PostgreSQL

Die CASE-Struktur ist ein logischer Ausdruck, der innerhalb von SQL-Abfragen eingesetzt wird. Sie überprüft Bedingungen nacheinander und gibt den ersten zutreffenden Wert zurück. Das ermöglicht eine flexible Verarbeitung und Transformation von Daten direkt im SELECT-Befehl.

Ein CASE-Block besteht üblicherweise aus folgenden Elementen:

• CASE: Startet den logischen Block
• WHEN: Definiert eine Bedingung
• THEN: Gibt den Wert zurück, wenn die Bedingung zutrifft
• END: Beendet den CASE-Ausdruck

Beispiel für eine CASE-Anweisung innerhalb eines SELECT-Statements:

SELECT 
    column1,
    column2,
    CASE 
        WHEN condition1 THEN 'Wert A'
        WHEN condition2 THEN 'Wert B'
        ELSE 'Standardwert'
    END AS ergebnis_spalte
FROM deine_tabelle;

Zulässige Vergleichsoperatoren:

• =: Gleich
• <: Kleiner als
• <=: Kleiner gleich
• >: Größer als
• >=: Größer gleich

Beispieldatenbank vorbereiten

Um das Verhalten der CASE-Anweisung zu zeigen, erstellen wir ein Schema mit zwei Tabellen: students und marks.

Mit dem PostgreSQL-Server verbinden

Stelle die Verbindung über den psql-Client her:

$ psql -h <host> -p <port> -U <username> defaultdb

Datenbank school erstellen

defaultdb=> CREATE DATABASE school;

Mit der neuen Datenbank verbinden

defaultdb=> \c school;

Tabelle students erstellen

Erzeuge eine Tabelle für die Stammdaten der Studierenden:

school=> CREATE TABLE students (
            student_id SERIAL PRIMARY KEY,
            first_name VARCHAR(50),
            last_name VARCHAR(50)
        );

Beispieldaten für Studierende einfügen

school=> INSERT INTO students (first_name, last_name) VALUES
          ('JOHN', 'DOE'),
          ('JANE', 'SMITH'),
          ('PETER', 'HENRY'),
          ('MARY', 'ANN'),
          ('JESSICA', 'WILLIAMS'),
          ('BOB', 'JAMES'),
          ('ESTHER', 'CHLOE');

Daten der Tabelle anzeigen

school=> SELECT student_id, first_name, last_name FROM students;

Ausgabe:

 student_id | first_name | last_name
------------+------------+-----------
        1   | JOHN       | DOE
        2   | JANE       | SMITH
        3   | PETER      | HENRY
        4   | MARY       | ANN
        5   | JESSICA    | WILLIAMS
        6   | BOB        | JAMES
        7   | ESTHER     | CHLOE
(7 rows)

Tabelle marks erstellen

Jetzt wird eine Tabelle für die Punktzahlen der Studierenden angelegt:

school=> CREATE TABLE marks (
            score_id SERIAL PRIMARY KEY,
            student_id INT,
            score INT
        );

Punktzahlen einfügen

school=> INSERT INTO marks (student_id, score) VALUES
          (1, 85),
          (2, 39),
          (3, 70),
          (4, 55),
          (5, 0),
          (6, 41),
          (7, 32);

Inhalt der marks-Tabelle anzeigen

school=> SELECT score_id, student_id, score FROM marks;

Ausgabe:

 score_id | student_id | score
----------+------------+-------
        1 |          1 |    85
        2 |          2 |    39
        3 |          3 |    70
        4 |          4 |    55
        5 |          5 |     0
        6 |          6 |    41
        7 |          7 |    32
(7 rows)

CASE-Anweisung zum Berechnen von Noten nutzen

Mit einer CASE-Konstruktion lassen sich Noten direkt aus den Punktzahlen berechnen. Dafür werden students und marks per LEFT JOIN verknüpft und abhängig von der Punktzahl eine Note zugeordnet.

school=> SELECT
             students.student_id,
             students.first_name,
             students.last_name,
             marks.score,
             CASE
                 WHEN marks.score >= 75 THEN 'Distinction'
                 WHEN marks.score >= 70 THEN 'Credit'
                 WHEN marks.score >= 40 THEN 'Pass'
                 ELSE 'Fail'
             END AS grade
         FROM marks
         LEFT JOIN students ON marks.student_id = students.student_id;

Notenschlüssel:

• Distinction: ab 75 Punkten
• Credit: 70–74 Punkte
• Pass: 40–69 Punkte
• Fail: unter 40 Punkte

Erwartete Ausgabe:

 student_id | first_name | last_name | score |    grade
------------+------------+-----------+-------+-------------
          1 | JOHN       | DOE       |    85 | Distinction
          2 | JANE       | SMITH     |    39 | Fail
          3 | PETER      | HENRY     |    70 | Credit
          4 | MARY       | ANN       |    55 | Pass
          5 | JESSICA    | WILLIAMS  |     0 | Fail
          6 | BOB        | JAMES     |    41 | Pass
          7 | ESTHER     | CHLOE     |    32 | Fail
(7 rows)

Dieses Beispiel zeigt, wie die CASE-Anweisung klar strukturiertes, bedingtes Verhalten innerhalb einer SQL-Abfrage ermöglicht – ideal zur Datenklassifikation oder regelbasierten Transformation.

Fazit

In dieser Einführung hast du gelernt, wie man mit PostgreSQL und der CASE-Anweisung eine einfache Datenbank erstellt und Punktzahlen in Noten umwandelt. Diese Technik eignet sich hervorragend für Berichte, Bewertungen oder andere konditionale Auswertungen. Für komplexere Logiken kannst du zusätzlich Mapping-Tabellen, IF-Statements oder semantische Werkzeuge wie pgvector in Betracht ziehen. Die offizielle Dokumentation von PostgreSQL bietet weitere Informationen zu bedingten Ausdrücken.