Datentypen und ihre Verwendung in PL/pgSQL: INTEGER, TEXT, BOOLEAN, RECORD

In dieser Vorlesung schauen wir uns an, welche Datentypen in PL/pgSQL unterstützt werden und wie man effektiv mit ihnen arbeitet. Der Fokus liegt auf vier Datentypen:

• INTEGER für Zahlen.
• TEXT für Strings.
• BOOLEAN für logische Werte.
• RECORD für dynamische Datenstrukturen.

Jeden Datentyp schauen wir uns anhand von Beispielen an, damit du sie direkt in der Praxis siehst.

Unterstützte Datentypen in PL/pgSQL

PL/pgSQL unterstützt alle Datentypen, die du schon aus PostgreSQL kennst. Von einfachen Zahlen (INTEGER, NUMERIC) bis zu komplexeren Sachen wie Arrays und JSONB. Lass uns die wichtigsten anschauen.

1. Primitive Typen:

   • INTEGER, BIGINT, FLOAT, NUMERIC — Zahlentypen.
   • TEXT, CHAR, VARCHAR — Texttypen.
   • BOOLEAN — logischer Datentyp.

2. Komplexe Typen:

   • RECORD — für dynamische Datensätze.
   • ROWTYPE — für Tabellenzeilentypen.
   • Arrays und JSON — das schauen wir uns später im Kurs an.

Arbeiten mit dem Typ INTEGER

INTEGER ist einer der meistgenutzten Datentypen. Er wird verwendet, um ganze Zahlen zu speichern. In PL/pgSQL kannst du diesen Typ für Berechnungen, Arbeiten mit IDs und Bedingungsprüfungen nutzen.

Beispiel: Anzahl der Datensätze zählen

Angenommen, wir haben eine Tabelle students und wollen wissen, wie viele Studenten in der Datenbank sind.

DO $$
DECLARE
    total_students INTEGER; -- Variable zum Speichern der Anzahl der Studenten
BEGIN
    SELECT COUNT(*) INTO total_students FROM students; -- Ergebnis der Abfrage in die Variable speichern
    RAISE NOTICE 'Anzahl der Studenten: %', total_students; -- Nachricht ausgeben
END;
$$;

Wichtige Punkte beim Arbeiten mit INTEGER:

• In PL/pgSQL weist du einer Variable einen Wert mit dem Schlüsselwort INTO zu.
• Wenn du versuchst, einen Dezimalwert in INTEGER zu speichern, gibt es einen Fehler. Für solche Fälle nimm NUMERIC oder FLOAT.

Arbeiten mit dem Typ TEXT

TEXT wird verwendet, um Strings zu speichern. Das brauchst du, wenn du mit Namen, Beschreibungen oder anderen Texten arbeitest.

Beispiel: Namen der Studenten ausgeben

In diesem Beispiel geben wir die Namen aller Studenten aus der Tabelle students aus.

DO $$
DECLARE
    student_name TEXT; -- Variable für den Namen des Studenten
BEGIN
    FOR student_name IN SELECT name FROM students LOOP
        RAISE NOTICE 'Name des Studenten: %', student_name; -- Jeden Namen ausgeben
    END LOOP;
END;
$$;

Nützliche Funktionen für TEXT:

• UPPER() und LOWER() — Umwandlung in Groß-/Kleinschreibung.
• CONCAT() — Strings zusammenfügen.
• LENGTH() — Länge des Strings.

Zum Beispiel:

DO $$
DECLARE
    full_name TEXT;
BEGIN
    full_name := CONCAT('Alex', ' Min'); -- Strings zusammenfügen
    RAISE NOTICE 'Vollständiger Name: %', UPPER(full_name); -- Name in Großbuchstaben ausgeben
END;
$$;

Arbeiten mit dem Typ BOOLEAN

BOOLEAN speichert logische Werte: TRUE, FALSE und NULL. Dieser Typ ist besonders praktisch für Bedingungen und Filter.

Beispiel: Überprüfen, ob ein Student aktiv ist

Angenommen, du hast eine Tabelle students mit einer Spalte is_active, die zeigt, ob ein Student aktiv ist.

DO $$
DECLARE
    is_active BOOLEAN; -- Variable für den Aktivitätsstatus
BEGIN
    SELECT is_active INTO is_active FROM students WHERE id = 1; -- Wert aus der Tabelle holen
    IF is_active THEN
        RAISE NOTICE 'Student ist aktiv!';
    ELSE
        RAISE NOTICE 'Student ist NICHT aktiv.';
    END IF;
END;
$$;

Wichtige Punkte beim Arbeiten mit BOOLEAN:

• Logische Werte kannst du direkt in IF und WHILE verwenden.
• NULL gilt als "unbestimmt", das solltest du bei Prüfungen beachten.

Arbeiten mit dem Typ RECORD

RECORD ist ein mächtiger Datentyp, mit dem du Zeilen ohne vorher festgelegte Struktur speichern kannst. Das ist besonders nützlich, wenn du mit SQL-Abfragen arbeitest, die mehrere Spalten zurückgeben.

Beispiel: Alle Datensätze der Tabelle durchgehen

Im nächsten Beispiel gehen wir alle Datensätze der Tabelle students durch und geben Name und ID jedes Studenten aus.

DO $$
DECLARE
    student RECORD; -- Dynamischer Typ für eine Datenzeile
BEGIN
    FOR student IN SELECT id, name FROM students LOOP
        RAISE NOTICE 'ID: %, Name: %', student.id, student.name; -- Auf Spalten der Zeile zugreifen
    END LOOP;
END;
$$;

Wichtige Punkte beim Arbeiten mit RECORD:

• Variablen vom Typ RECORD werden nur im Loop oder mit SELECT INTO gefüllt.
• Auf Spalten greifst du mit record.spaltenname zu.

Datentyp ROWTYPE für Tabellen

Wenn du einen kompletten Datensatz aus einer Tabelle speichern willst (und dabei eine klare Typisierung willst), kannst du ROWTYPE verwenden. Der Typ übernimmt automatisch die Struktur der Tabellenzeile.

Beispiel: Arbeiten mit ROWTYPE

DO $$
DECLARE
    student students%ROWTYPE; -- Variable mit der Struktur der students-Tabelle
BEGIN
    SELECT * INTO student FROM students WHERE id = 1; -- Zeilendaten in die Variable laden
    RAISE NOTICE 'Name des Studenten: %, Kurs: %', student.name, student.course;
END;
$$;

Unterschiede zwischen RECORD und ROWTYPE

Praktisches Beispiel

Lass uns eine Funktion schreiben, die die Anzahl der aktiven Studenten und ihre Namen zurückgibt.

CREATE FUNCTION active_students_report() RETURNS TABLE(id INT, name TEXT) AS $$
BEGIN
    RETURN QUERY
    SELECT id, name FROM students WHERE is_active = TRUE;
END;
$$ LANGUAGE plpgsql;

Funktionsaufruf:

SELECT * FROM active_students_report();

Fehler beim Arbeiten mit Datentypen

Manchmal passieren Fehler beim Umgang mit Daten. Hier ein paar typische Fälle:

• Typfehler: Versuch, einen String in eine INTEGER-Variable zu schreiben (zum Beispiel my_var := 'abc';).
• Verwendung von NULL dort, wo TRUE oder FALSE erwartet wird.
• Falsche Verwendung von RECORD ohne Initialisierung.

So vermeidest du Fehler:

• Gib den Typ von Variablen immer explizit an.
• Prüfe die Datentypen der Tabellenspalten vor dem Schreiben.
• Nutze Debug-Kommandos wie RAISE NOTICE.

Jetzt weißt du, wie du mit den Datentypen INTEGER, TEXT, BOOLEAN und RECORD in PL/pgSQL arbeitest. Dieses Wissen hilft dir, komplexere und mächtigere Programme in der prozeduralen Programmiersprache von PostgreSQL zu schreiben.