Vom ersten SELECT bis zum Failover. Ein Weg, zwei Kurse.

Das Fundament: das relationale Modell, die Werkzeuge, Abfragen, Typen, Joins und Auswertungen. Am Ende von Modul 1 lassen sich Fragen an die Kursdatenbank direkt in SQL beantworten.

1. Datenbanken und das relationale Modell verstehen Tabellen, Schlüssel und Beziehungen (1:n, n:m) benennen; Integritätsregeln und die ersten drei Normalformen begründen; einordnen, was PostgreSQL ist und was nicht.
2. Erste Schritte mit psql und einem Client Instanz, Datenbank und Schema unterscheiden; psql-Metabefehle und einen grafischen Client nutzen; `search_path` verstehen; Verbindungsfehler an ihrer Meldung erkennen.
3. SELECT, WHERE, ORDER BY, LIMIT Logische Auswertungsreihenfolge, dreiwertige Logik mit NULL, `NOT IN`-Falle, Muster mit `LIKE`/`ILIKE`, deterministisch sortieren und begrenzen, lesbar formatieren.
4. Datentypen in PostgreSQL richtig wählen `integer`/`bigint`/`numeric` gegen Gleitkomma, `text` gegen `varchar(n)`, `timestamptz` und die Zeitumstellung, `boolean`, UUID mit `uuidv7()` (neu in PostgreSQL 18), Identity statt `serial`, Arrays und JSONB im Überblick.
5. Joins systematisch meistern INNER, LEFT und FULL OUTER JOIN, Join-Ketten, Self-Joins, Unterabfragen mit `IN`, `EXISTS` und `NOT EXISTS`; die Position einer Bedingung in `ON` oder `WHERE`; Kreuzprodukt und falsche Join-Spalte als Fehlerbild.
6. Aggregation und Gruppierung Aggregatfunktionen und NULL, `GROUP BY`, `WHERE` gegen `HAVING`, die Zählfallen `count(*)` und Vervielfachung durch Joins, `FILTER`, Zwischenergebnisse mit `WITH`.

Vom Lesen zum Schreiben: Daten ändern, Regeln entwerfen, Änderungen absichern und Abfragen kapseln.

1. INSERT, UPDATE, DELETE und Konflikte Schreibende Statements, `RETURNING` mit `old` und `new` (neu in PostgreSQL 18), Änderungen anhand einer zweiten Tabelle, Upserts mit `ON CONFLICT`, `MERGE` im Überblick, der Reflex „erst SELECT, dann ändern“.
2. DDL: Tabellen und Constraints entwerfen Die Constraint-Palette mit sprechenden Namen, Constraints an bestehende Tabellen anfügen, `ON DELETE` (`RESTRICT`, `CASCADE`, `SET NULL`) im Klartext begründen, Integrität gegen Prozesslogik abgrenzen.
3. Transaktionen für Anfänger, richtig erklärt `BEGIN`, `COMMIT`, `ROLLBACK`, `SAVEPOINT`; der abgebrochene Transaktionszustand; was Transaktionen nicht leisten; offene Änderungen, wartende Schreiber und verlorene Updates mit zwei Sitzungen beobachten.
4. Sichten, Materialized Views und einfache Funktionen Views als gespeicherte Abfragen, Materialized Views mit `REFRESH` und dem Preis der Aktualität, SQL-Funktionen mit Parametern, Abhängigkeiten zwischen Objekten.

Daten von außen hereinholen und den ersten bewussten Blick in den Ausführungsplan werfen. Einheit 12 ist die Übergabe an das Engineer Training.

1. Import und Export von Daten `COPY` und `\copy`, die vier CSV-Fehler (Trennzeichen, Quoting, Kodierung, Zahlenformat), Struktur- gegen Inhaltsfehler, das Importmuster mit Zwischentabelle und Protokoll, `ON_ERROR` und `REJECT_LIMIT`.
2. Der erste bewusste Blick auf EXPLAIN Pläne lesen, Schätzung und Messung vergleichen, Seq Scan, Index Scan und Bitmap Heap Scan unterscheiden, die Wirkung eines Index belegen, fehlende Indizes auf Fremdschlüsseln erkennen.

1. Rollen, Berechtigungen, pg_hba.conf lesen Login- und Gruppenrollen, `GRANT`/`REVOKE` auf allen Ebenen, Standardrechte von `PUBLIC`, `pg_hba.conf` lesen und ändern, jede Fehlermeldung ihrer Kontrollebene zuordnen.
2. Backup und Restore in den Grundzügen `pg_dump` in drei Formaten, `pg_restore` vollständig und in Teilen, was ein Dump nicht enthält (Rollen, Konfiguration, in PostgreSQL 18 standardmäßig keine Statistiken), RPO und RTO, warum `pg_dump` kein PITR ist.

1. OR-Mapper verstehen statt fürchten Das SQL eines Mappers sichtbar machen, das N+1-Muster messen und beheben, Transaktionsgrenzen im Framework, Verbindungspools, bewusster Wechsel zu SQL; Übersetzung nach JPA, EF Core und Django.
2. SQL-Injection und parametrisierte Abfragen Den Mechanismus der Injection verstehen, parametrisierte Abfragen in psycopg, JDBC und ORMs, sichere Behandlung von Spaltennamen, LIKE-Mustern und Wertelisten, minimale Rechte als zweite Schicht.

Bevor es um Performance, Betrieb und Architektur geht, steht das Verständnis der Mechanik: wie PostgreSQL eine Abfrage plant und ausführt, wie Transaktionen sich gegenseitig sehen und sperren, und wie MVCC und VACUUM zusammenwirken. Auf diesen fünf Einheiten baut der gesamte Lehrgang auf.

1. Query-Verarbeitung in PostgreSQL verstehen Die fünf Phasen Parser, Rewrite, Planner, Executor, Portal kennen. Verstehen, wie ein SQL-Statement intern abläuft.
2. EXPLAIN und EXPLAIN ANALYZE meistern Plan-Operatoren lesen (Seq Scan, Index Scan, Nested Loop, Hash Join, Merge Join), Kosten vs. tatsächliche Zeilen interpretieren, Buffers- (seit PG 18 bei ANALYZE standardmäßig an) und Timing-Output nutzen, `MEMORY`/`SERIALIZE` (PG 17) kennen.
3. Statistiken und der Query-Planner `pg_statistic` und `pg_stats`, Bedeutung von `n_distinct`, Histogrammen und Korrelation. `ANALYZE`, Autovacuum-Analyse, `default_statistics_target`.
4. Transaktionen, Isolation und Locks MVCC, Snapshot-Isolation, die vier Isolationsstufen in PostgreSQL, Serialisierung per SSI. Tabellen- und Zeilensperren, Lock-Warteschlange, Deadlocks, `pg_locks`, Lock-Timeouts. Dauerhaftigkeit über WAL, Commit und Checkpoints, `synchronous_commit`.
5. VACUUM und MVCC-Wartung verstehen Seitenaufbau, Tuple-Versionen, Dead Tuples, Bloat, HOT-Updates und fillfactor, Free Space Map, Visibility Map. Autovacuum-Tuning, `VACUUM` vs. `VACUUM FREEZE` vs. `VACUUM FULL`, Wraparound-Gefahr.

1. Index-Typen im Überblick B-Tree, Hash, GIN, GiST, SP-GiST, BRIN. Wann welcher Index passt, Funktionsweise von GIN (Posting-Listen) und BRIN (Range-Blöcke).
2. Fortgeschrittene Index-Techniken Partielle Indizes, funktionsbasierte Indizes, mehrspaltige Indizes und Column-Order, Covering Indizes (`INCLUDE`), `CREATE INDEX CONCURRENTLY`, `REINDEX CONCURRENTLY`, `pg_stat_user_indexes` (Hit-Rate, ungenutzte Indizes).
3. Query-Optimierung in der Praxis Anti-Pattern (N+1, `SELECT *`, OR-Verrenkungen, `OFFSET`-Pagination), CTE-Materialisierung steuern (`MATERIALIZED`/`NOT MATERIALIZED` seit PG 12), Fensterfunktionen effizient einsetzen, Keyset-Pagination, `work_mem` und Spills.
4. Connection-Management und Pooling PostgreSQL-Prozessmodell, Kosten pro Verbindung, `max_connections`, PgBouncer (Session vs. Transaction vs. Statement Mode), prepared Statements im Pool, Timeout-Strategien.

1. Datenmodellierung jenseits der Normalform Normalformen, Schlüssel- und Datentypwahl, bewusste Denormalisierung, Materialized Views, Array- und JSONB-Spalten (wann Dokumentenmodell, wann relationales Modell), `CHECK`-Constraints, Composite Types.
2. Partitionierung Deklarative Range-, List- und Hash-Partitionierung, Partition Pruning, Partition-wise Joins, Routing über Partition Keys, Verwaltung von Partitionen, Grenzen (Indexe je Partition).
3. Schema-Migrationen professionell ausführen Lock-Auswirkungen von DDL, `NOT VALID` + `VALIDATE`, gleichzeitige Index- und Constraint-Builds, Squash von Migrationen. Flyway, Liquibase und Sqitch im Vergleich, Rollback-Strategien, Baseline aus bestehender DB.

1. Backup und Recovery `pg_dump` vs. `pg_basebackup` vs. WAL-basierte Backups, inkrementelle Bordmittel-Backups seit PG 17 (`pg_basebackup --incremental`, `pg_combinebackup`). pgBackRest einrichten (inkrementelle Backups, Retention, Kompression), PITR (Point-in-Time-Recovery), `recovery_target_time`, Verifikation von Backups.
2. Replikation Streaming-Replication (synchron vs. asynchron), WAL-Interna, Replication-Slots (Failover-Slots seit PG 17, `idle_replication_slot_timeout` seit PG 18), `hot_standby` und Query-Konflikte, logische Replikation (Publications, Subscriptions, `pg_createsubscriber`, Konfliktstatistik seit PG 18).
3. Hochverfügbarkeit mit Patroni Architektur von Patroni (etcd/Konsens, Leader-Wahl, `pg_hba`-Automatisierung), pg_auto_failover als einfachere Alternative, Split-Brain vermeiden, Routing-Layer (HAProxy, Health-Checks).
4. PostgreSQL-Konfiguration und Tuning `shared_buffers`, `effective_cache_size`, `work_mem`, `maintenance_work_mem`, WAL-Einstellungen (`max_wal_size`, `synchronous_commit`), `autovacuum_*`-Grundlagen, asynchrones I/O seit PG 18 (`io_method`, `effective_io_concurrency`), Restart vs. Reload, Conf-Management über `ALTER SYSTEM`.

1. Monitoring mit Prometheus und postgres_exporter Kern-Metriken (Verbindungen, WAL, Replikations-Lag, Autovacuum-Rückstand), postgres_exporter-Queries und Custom-Metriken, Alertmanager-Regeln für Lag, Disk-Füllstand, Transaktionsalter und Lock-Wartezeiten.
2. pg_stat_statements und Workload-Analyse Top-Queries nach Gesamtzeit und Aufrufen, `shared_blks_*` interpretieren, Regressionserkennung nach Releases, ergänzende Views (`pg_stat_user_tables`, `pg_stat_io` ab PG 16, `pg_wait_sampling`).
3. Infrastructure as Code für Datenbanken Docker Compose für lokale Setups, Ansible oder Terraform für Instanz-Setup, Konfig-Drift vermeiden, Secrets-Handling, reproduzierbare Umgebungen. Optional: PostgreSQL in Kubernetes (CloudNativePG).

1. Rollen- und Rechtekonzept Rollen-Hierarchien (Mitgliedschafts-Optionen seit PG 16), `GRANT`-Strategien, Default Privileges, `SECURITY DEFINER`-Risiken, separate App- und Admin-Rollen, `pg_hba.conf` und SCRAM-Authentifizierung (MD5 seit PG 18 abgekündigt).
2. Row Level Security und Mandanten-Trennung RLS-Policies, Rollen-Wechsel (`SET ROLE`), Performance-Auswirkungen von RLS, Mandantenmodelle (Schema-per-Tenant vs. Shared Tables mit `tenant_id` + RLS).
3. Auditing, Verschlüsselung und DSGVO-Betrieb `pgAudit`, `log_statement`-Strategien, TLS erzwingen, Verschlüsselung im Ruhezustand (LUKS, Cloud-KMS), Anonymisierung mit `anon`-Extension, Aufbewahrungsfristen und Löschkonzepte (`DELETE` vs. Partition-Drop).

1. PostGIS — Räumliche Daten und Abfragen Geometrie-Typen, SRIDs, räumliche Indizes (GiST), Distanz- und Enthält-Abfragen, Geocoding-Workflows.
2. Volltextsuche mit tsvector und pg_trgm `to_tsvector`/`to_tsquery`, Ranking (ts_rank), GIN vs. GiST, Fuzzy-Suche mit `pg_trgm` und Ähnlichkeitsoperatoren, Kombination beider Ansätze.
3. pgvector und KI-Workloads — Semantische Suche und Hybrid-Ranking Embeddings speichern (pgvector 0.8: `vector`, `halfvec`), HNSW- vs. IVFFlat-Index, Ähnlichkeitssuche, gefilterte Suche mit iterativem Index-Scan, Hybrid Search (Vektor + Volltext), PostgreSQL als Vektor-Backend bewerten.
4. Citus und horizontale Skalierung — Sharding jenseits der einzelnen Instanz Sharding-Konzepte, Verteilungsschlüssel, Co-Located Joins, Rebalancer. Abgrenzung: wann reicht eine große einzelne Instanz, wann Citus oder ein anderes System.
5. Migration von Oracle oder MySQL nach PostgreSQL — Werkzeuge, Fallen, Cutover Typ-Mapping, Sequences vs. Auto-Increment, PL/SQL-Übersetzung (Ora2Pg), Casing- und Empty-String-Fallen, Teststrategie mit Schatten-Deployments und Dual-Writes.

1. Kapazitätsplanung und Sizing — Messwerte, Szenarien, Kalender Wachstumsmodelle, IOPS- und Throughput-Schätzungen, Storage-Kalkulation (WAL, Bloat, Backups), Hardware- und Cloud-Sizing, Grenzen einer Instanz abschätzen.
2. Incident Response und Post-Mortems — Runbooks, Rollen, Ruf-Schwellen Runbooks (Replikations-Lag, Disk voll, Autovacuum-Rückstand, Lock-Sturm), Eskalationspfade, Kommunikationsregeln während Incidents, Post-Mortem-Kultur ohne Schuldzuweisung.
3. Database Reliability Engineering — SLOs, Drills und die Zuverlässigkeits-Pipeline SLOs für Datenbanken (Verfügbarkeit, Replikations-Lag, Query-Latenz-P99), Error Budgets, Chaos-Tests (Kill Primary unter Last), automatisierte Failover-Drills, Backup-Restore-Tests als CI-Job.
4. Architektur-Reviews und Standards im Team — Checklisten, ADRs, Trade-offs Schema- und Migration-Review-Checkliste, Index-Standards, Benennungskonventionen, technische Entscheidungen dokumentieren (ADR), Trade-off-Analysen (z. B. RLS vs. App-Layer-Sicherheit, Partitionierung vs. Archivierung).
5. Mentoring und Stakeholder-Kommunikation — Erklären, Onboarding, Kosten bewerten Komplexe technische Sachverhalte für Nicht-Spezialisten erklären, Onboarding-Material für Junior-Kollegen erstellen, Datenbank-Themen in Projektplanungen einbringen, Kostentreiber (Cloud-Services vs. Self-Hosting) gegenüber dem Business bewerten.