Trigger-Syntax-Grundlagen: CREATE TRIGGER, WHEN, EXECUTE FUNCTION

Um einen Trigger in PostgreSQL zu erstellen, musst du folgende Komponenten angeben:

• Name des Triggers.
• Event-Typ (INSERT, UPDATE, DELETE).
• Ausführungszeitpunkt (BEFORE oder AFTER).
• Tabelle, auf die er sich bezieht.
• Funktion, die ausgeführt wird (in PL/pgSQL oder einer anderen Sprache).

Hier ist die allgemeine Struktur des Befehls:

CREATE TRIGGER trigger_name
[BEFORE | AFTER] {INSERT | UPDATE | DELETE}
ON table_name
[FOR EACH ROW | FOR EACH STATEMENT]
WHEN (bedingung)
EXECUTE FUNCTION function_name();

Beispiel für einen einfachen Trigger

Lass uns eine Basistabelle students erstellen und einen Trigger hinzufügen, der nach dem Hinzufügen eines neuen Eintrags ausgelöst wird.

Erstmal erstellen wir die Tabelle students

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    last_modified TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Was passiert hier? Wir haben eine Tabelle mit den Feldern id, name und last_modified erstellt. Das Feld last_modified speichert Datum und Uhrzeit der letzten Änderung des Eintrags.

Trigger sind immer an Funktionen gebunden. Zuerst erstellen wir eine einfache Funktion, die das Feld last_modified bei jedem Einfügen aktualisiert:

CREATE OR REPLACE FUNCTION update_last_modified()
RETURNS TRIGGER AS $$
BEGIN
    -- Setze das aktuelle Datum und die aktuelle Uhrzeit ins Feld last_modified
    NEW.last_modified := CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

Was ist das für Magie?

1. NEW — eine spezielle Variable, die die neuen Werte der Zeile speichert (für INSERT oder UPDATE Events).
2. CURRENT_TIMESTAMP — Funktion, die das aktuelle Datum und die aktuelle Uhrzeit zurückgibt.
3. RETURN NEW — gibt die geänderte Zeile zum Speichern zurück.

Jetzt erstellen wir den Trigger selbst:

CREATE TRIGGER set_last_modified
AFTER INSERT
ON students
FOR EACH ROW
EXECUTE FUNCTION update_last_modified();

Erklärung:

• AFTER INSERT: Der Trigger wird nach dem Hinzufügen einer neuen Zeile ausgelöst.
• ON students: Der Trigger gilt für die Tabelle students.
• FOR EACH ROW: Der Trigger wird für jede neue Zeile ausgelöst.
• EXECUTE FUNCTION: Gibt an, welche Funktion aufgerufen werden soll.

Trigger testen

Lass uns testen, wie unser Trigger funktioniert:

INSERT INTO students (name) VALUES ('Alice');
SELECT * FROM students;

Du siehst ungefähr folgendes Ergebnis:

Der Trigger hat das Feld last_modified automatisch aktualisiert. Magie? Nope, einfach nur PostgreSQL.

Bedingungen mit WHEN nutzen

Manchmal soll ein Trigger nicht immer, sondern nur unter bestimmten Bedingungen ausgeführt werden. Dafür gibt es das Schlüsselwort WHEN.

Schauen wir uns ein Beispiel an, bei dem der Trigger nur für bestimmte Werte ausgelöst wird.

Angenommen, wir wollen, dass der Trigger nur für Studenten mit dem Namen "Alice" ausgelöst wird. Wir ändern unseren Trigger:

CREATE OR REPLACE FUNCTION update_last_modified_condition()
RETURNS TRIGGER AS $$
BEGIN
    NEW.last_modified := CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER set_last_modified_condition
AFTER INSERT
ON students
FOR EACH ROW
WHEN (NEW.name = 'Alice')
EXECUTE FUNCTION update_last_modified_condition();

Jetzt aktualisiert der Trigger das Feld last_modified nur für Studenten mit dem Namen "Alice".

Testen wir das:

INSERT INTO students (name) VALUES ('Alice');
INSERT INTO students (name) VALUES ('Bob');
SELECT * FROM students;

Ergebnis:

Achte darauf: Für den Studenten "Bob" bleibt das Feld last_modified leer, weil der Trigger nicht ausgelöst wurde.

Verbindung zwischen Trigger und Funktion: EXECUTE FUNCTION

Die Funktion ist das Herzstück jedes Triggers. Ein Trigger kann nicht ohne eine Funktion existieren, die seine Logik definiert. In PostgreSQL kannst du Funktionen in PL/pgSQL oder anderen unterstützten Sprachen wie Python oder C schreiben.

Hier ein Beispiel mit einer PL/pgSQL-Funktion.

Wir erstellen eine Funktion, die Änderungen in einer separaten Tabelle audit_log protokolliert.

Erstmal erstellen wir die Tabelle audit_log

CREATE TABLE audit_log (
    id SERIAL PRIMARY KEY,
    operation TEXT NOT NULL,
    student_id INTEGER NOT NULL,
    log_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Und jetzt – die Funktion:

CREATE OR REPLACE FUNCTION log_insert()
RETURNS TRIGGER AS $$
BEGIN
    INSERT INTO audit_log (operation, student_id)
    VALUES ('INSERT', NEW.id);
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

Jetzt schreiben wir den Trigger:

CREATE TRIGGER log_student_insert
AFTER INSERT
ON students
FOR EACH ROW
EXECUTE FUNCTION log_insert();

Und testen das Ganze:

INSERT INTO students (name) VALUES ('Charlie');
SELECT * FROM audit_log;

Du siehst ungefähr folgendes Ergebnis:

Der Trigger hat automatisch einen Log-Eintrag für den neuen Datensatz erstellt.

Fehler und Besonderheiten bei Triggern

Fehler: Funktion fehlt. Wenn du versuchst, einen Trigger ohne Funktion zu erstellen, gibt PostgreSQL einen Fehler aus. Erstelle immer zuerst die Funktion, bevor du den Trigger anlegst.

Performance-Probleme. Viele Trigger oder komplexe Funktionen können die Datenbank verlangsamen. Benutze sie mit Bedacht.

Rekursion. Wenn ein Trigger Änderungen an derselben Tabelle vornimmt, auf der er ausgelöst wird, kann das zu einer Endlosschleife führen. Nutze WHEN-Bedingungen, um das zu vermeiden.