Automatische Berichtserstellung nach Zeitplan

Wenn du mit kleinen Datenbanken arbeitest, ist es kein Problem, Abfragen oder Prozeduren für Berichte von Hand zu starten. Aber in der echten Welt wachsen Datenbanken schnell, und dann muss man wiederkehrende Aufgaben automatisieren. Stell dir vor, du wirst jeden Tag gebeten, einen Verkaufsbericht zu erstellen. Selbst wenn die Abfrage nur zwei Minuten dauert, verballerst du im Jahr mehr als 12 Stunden nur dafür. Die Zeit verbringst du doch lieber mit 'nem Kaffee, während die automatische Prozedur alles für dich erledigt.

Automatisierung hilft dir dabei:

• Weniger Handarbeit.
• Regelmäßige Berichte (z.B. täglich, wöchentlich).
• Weniger Fehler durch menschliche Faktoren.
• Mehr Vertrauen in deine Berichte: Sie werden immer nach festen Parametern erstellt.

Die wichtigsten Schritte zur automatischen Berichtserstellung

Automatisches Ausführen von Berichten läuft so ab:

1. Eine Prozedur in PL/pgSQL schreiben, die den Bericht erstellt.
2. Ergebnisse loggen (wenn nötig).
3. Einen Taskplaner nutzen, um die Prozedur nach Zeitplan zu starten.

Lass uns das Schritt für Schritt umsetzen!

Prozedur zur Berichtserstellung schreiben

Wir starten mit einer einfachen Prozedur, die den Gesamtumsatz aller Bestellungen für den aktuellen Tag berechnet und das Ergebnis in einer Log-Tabelle speichert. Unsere Log-Tabelle gibt's schon (nennen wir sie sales_report_log):

CREATE TABLE sales_report_log (
    report_date DATE NOT NULL,
    total_sales NUMERIC NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Jetzt schreiben wir die Prozedur in PL/pgSQL:

CREATE OR REPLACE FUNCTION generate_daily_sales_report()
RETURNS VOID AS $$
BEGIN
    -- Gesamtumsatz für den aktuellen Tag berechnen
    INSERT INTO sales_report_log (report_date, total_sales)
    SELECT CURRENT_DATE, SUM(order_total)
    FROM orders
    WHERE order_date = CURRENT_DATE;

    RAISE NOTICE 'Bericht für % erfolgreich erstellt', CURRENT_DATE;
END;
$$ LANGUAGE plpgsql;

Was passiert hier:

• Wir nutzen die Aggregatfunktion SUM(), um den Gesamtumsatz aus der Tabelle orders zu berechnen.
• Das Berichtsdatum (report_date) ist immer das aktuelle Datum (CURRENT_DATE).
• Das Ergebnis landet in der Tabelle sales_report_log.
• Die RAISE NOTICE-Meldung ist zum Debuggen da: Sie sagt, dass der Bericht erfolgreich erstellt wurde.

Prozedur testen

Bevor du die Prozedur automatisierst, solltest du sie immer manuell testen. Wir führen die Funktion aus:

SELECT generate_daily_sales_report();

Und jetzt checken wir den Inhalt der Tabelle sales_report_log:

SELECT * FROM sales_report_log;

Wenn du eine Zeile mit dem aktuellen Datum und dem richtigen Gesamtumsatz siehst – Glückwunsch, deine Funktion läuft!

Aufgaben in PostgreSQL automatisieren

Manchmal ist es praktisch, wenn die Datenbank selbst was macht: Berichte starten, alte Einträge löschen oder Aggregationen nach Zeitplan aktualisieren. PostgreSQL kann das mit dem pg_cron-Extension oder einem externen Taskplaner – dem System-cron oder Task Scheduler.

Wenn du auf Linux bist, ist pg_cron die beste Wahl. Das Extension startet SQL direkt in PostgreSQL, ohne dass du Shell oder Skripte brauchst.

Installieren kannst du pg_cron so (denk dran, XX durch deine PostgreSQL-Version zu ersetzen):

sudo apt install postgresql-XX-cron

Nach der Installation musst du es in der Config aktivieren. Öffne postgresql.conf und füge die Zeile hinzu:

shared_preload_libraries = 'pg_cron'

Dann PostgreSQL neu starten und das Extension in deiner Datenbank aktivieren:

CREATE EXTENSION pg_cron;

Jetzt kannst du einen Task planen. Zum Beispiel die Funktion generate_daily_sales_report() jeden Tag um Mitternacht starten:

SELECT cron.schedule(
    'daily_sales_report',
    '0 0 * * *',
    $$ SELECT generate_daily_sales_report(); $$
);

Hier:

• 'daily_sales_report' – Name des Tasks;
• '0 0 * * *' – Zeitplan im cron-Style (hier: täglich um 00:00);
• SQL zwischen $$ – der Code, der ausgeführt wird.

Um alle geplanten Tasks zu sehen, nutze:

SELECT * FROM cron.job;

Wenn du Windows oder macOS nutzt, wird pg_cron entweder gar nicht unterstützt (Windows) oder du musst es aufwendig selbst bauen (macOS). Das ist nervig, meistens ist es einfacher, den System-Taskplaner zu nehmen.

So geht's:

1. Erstelle eine SQL-Datei mit dem Befehl:

echo "SELECT generate_daily_sales_report();" > /path/to/script.sql

2. Nutze psql, um die Datei auszuführen:

psql -h localhost -U postgres -d your_database -f /path/to/script.sql

3. Füge diesen Befehl dem Taskplaner hinzu:

   • Auf Linux/macOS: mit crontab -e:

     0 0 * * * psql -h localhost -U postgres -d your_database -f /path/to/script.sql
     

   • Auf Windows: über den Task Scheduler, indem du einen Task erstellst, der psql.exe mit den nötigen Parametern startet.

• Wenn du auf Linux bist, nimm pg_cron – das ist bequem und direkt in PostgreSQL integriert.
• Wenn du auf Windows oder Mac bist, ist es sinnvoller, den System-Taskplaner (cron oder Task Scheduler) zu nutzen und SQL über psql zu starten.

So kannst du alle möglichen Aufgaben in PostgreSQL easy automatisieren.

Beispiele für automatische Berichte

1. Täglicher Bericht nach Regionen

Angenommen, du willst automatisch einen Bericht zum Umsatz in jeder Region erstellen. Du kannst unsere Funktion erweitern:

CREATE OR REPLACE FUNCTION generate_regional_sales_report()
RETURNS VOID AS $$
BEGIN
    INSERT INTO regional_sales_report_log (region, report_date, total_sales)
    SELECT region, CURRENT_DATE, SUM(order_total)
    FROM orders
    WHERE order_date = CURRENT_DATE
    GROUP BY region;

    RAISE NOTICE 'Regionaler Bericht für % erfolgreich erstellt', CURRENT_DATE;
END;
$$ LANGUAGE plpgsql;

2. Monatsbericht

Genauso kannst du eine Prozedur für Monatsberichte schreiben. Einfach den Filter in der Abfrage ändern:

WHERE order_date BETWEEN date_trunc('month', CURRENT_DATE)
                     AND date_trunc('month', CURRENT_DATE) + interval '1 month - 1 day';

Typische Fehler und wie du sie vermeidest

Bei automatischer Berichtserstellung können Probleme auftreten:

• Syntaxfehler in der Funktion: Teste Funktionen immer manuell, bevor du sie automatisierst.
• Zu häufige Ausführung: Wenn ein Task zu oft läuft, kann das die Datenbank stressen. Plane den Zeitplan mit Köpfchen.
• Doppelte Daten: Wenn der Bericht mehrmals am Tag läuft, gibt's evtl. Duplikate. Nutze eindeutige Keys, um Wiederholungen zu verhindern.

In dieser Vorlesung hast du gesehen, wie man automatische Berichtserstellung in PostgreSQL einrichtet. Jetzt kannst du deine Analyseprozesse optimieren und hast mehr Zeit für die wichtigen Dinge... zum Beispiel Bugs jagen, Code schreiben oder davon träumen, dass deine SQL-Queries perfekt sind.