Seminar Flask Datenbanken mit SQLAlchemy und Migrationen

Professionelle Datenbankintegration verlangt mehr als das Definieren einiger ORM-Klassen. Verbindungslebenszyklus, Modellregeln, Transaktionsgrenzen, Migrationen, Testdaten und Abfrageverhalten müssen gemeinsam geplant werden.

Das Seminar baut eine relationale Persistenzschicht schrittweise auf. SQLAlchemy wird factory-tauglich initialisiert, Modelle werden mit echten Integritätsregeln versehen und Datenzugriffe in Services gekapselt.

Inhaltsübersicht

1. SQLAlchemy-Integration und Sitzungsmanagement
2. Modelle, Beziehungen und Integritätsregeln
3. Abfragen, Transaktionen und Servicegrenzen
4. Schema-Migrationen und Datenänderungen
5. Service-, Repository- und Domänenschichten
6. Datenbanktests und Testdaten
7. pytest-Struktur und Fixtures
8. Integrations- und Migrationstests
9. Datenbank- und ORM-Optimierung
10. Praxisprojekt und Wissenssicherung

Lernziele

• SQLAlchemy factory-tauglich und umgebungsabhängig initialisieren.
• Modelle, Beziehungen und Integritätsregeln fachlich korrekt entwerfen.
• Transaktionen und Datenzugriffe in klaren Servicegrenzen steuern.
• Schema- und Datenmigrationen sicher entwickeln und prüfen.
• Datenbanktests und Performanceanalysen reproduzierbar durchführen.

Zielgruppe

Flask- und Backend-Entwickler, die relationale Datenbanken fachlich sauber, testbar und migrationsfähig integrieren müssen.

Voraussetzungen

Gute Python- und Flask-Grundlagen. Grundkenntnisse relationaler Datenbanken und SQL werden vorausgesetzt.

Seminarinhalte

1. SQLAlchemy-Integration und Sitzungsmanagement

Datenbankzugriffe werden über klar initialisierte Erweiterungen und requestgebundene Sessions organisiert.

1. Schritt 1: Datenbank-URL, Engine-Optionen und Verbindungsparameter je Umgebung festlegen.
2. Schritt 2: SQLAlchemy-Objekt ungebunden erzeugen und in der Application Factory mit init_app verbinden.
3. Schritt 3: Anwendungs- und Transaktionskontext für CLI, Tests und Requests korrekt öffnen.
4. Schritt 4: Verbindungsfehler, Poolgrenzen und sauberes Aufräumen reproduzierbar prüfen.

2. Modelle, Beziehungen und Integritätsregeln

Fachliche Datenstrukturen werden mit expliziten Schlüsseln, Constraints und nachvollziehbaren Beziehungen modelliert.

1. Schritt 1: Tabellen, Primärschlüssel, Datentypen und Nullbarkeit aus Fachregeln ableiten.
2. Schritt 2: Eins-zu-viele-, viele-zu-viele- und optionale Beziehungen mit klarer Eigentümerschaft definieren.
3. Schritt 3: Unique-, Check- und Foreign-Key-Regeln in der Datenbank statt nur in der Oberfläche verankern.
4. Schritt 4: Repräsentative Beispieldaten erzeugen und Integritätsverletzungen gezielt testen.

3. Abfragen, Transaktionen und Servicegrenzen

Lesen und Schreiben werden in Services gekapselt, damit Views keine unkontrollierte Datenbanklogik enthalten.

1. Schritt 1: Select-Abfragen mit Filtern, Sortierung, Pagination und gezielter Spaltenauswahl formulieren.
2. Schritt 2: Transaktionsgrenzen pro Anwendungsfall bestimmen und Commit beziehungsweise Rollback zentral steuern.
3. Schritt 3: N+1-Probleme und unnötige Lazy Loads mit geeigneten Ladeoptionen vermeiden.
4. Schritt 4: Paralleländerungen, verlorene Updates und fehlgeschlagene Commits in Tests simulieren.

4. Schema-Migrationen und Datenänderungen

Datenbankschemata werden versioniert, überprüft und mit sicheren Vorwärts- und Rückwärtswegen ausgeliefert.

1. Schritt 1: Migrationswerkzeug initialisieren und Metadaten der Anwendung korrekt anbinden.
2. Schritt 2: Autogenerierte Migrationen fachlich prüfen und manuelle Korrekturen dokumentieren.
3. Schritt 3: Schemaänderung und Datenmigration trennen, wenn Laufzeit oder Sperren kritisch werden.
4. Schritt 4: Upgrade, Downgrade und Neuaufbau der Datenbank in einer isolierten Umgebung testen.

5. Service-, Repository- und Domänenschichten

Geschäftslogik wird von HTTP und Persistenz getrennt, damit sie unabhängig testbar und wiederverwendbar bleibt.

1. Schritt 1: View-Funktionen auf Eingabe, Serviceaufruf und Response-Abbildung reduzieren.
2. Schritt 2: Services für Anwendungsfälle und Repositories für Datenzugriffe definieren.
3. Schritt 3: Domänenfehler statt HTTP-Ausnahmen aus tieferen Schichten zurückgeben.
4. Schritt 4: Servicefälle mit Fakes testen und Integrationspfade separat absichern.

6. Datenbanktests und Testdaten

Tests erhalten isolierte Datenbestände und verlassen die Datenbank in einem definierten Zustand.

1. Schritt 1: Eigene Testkonfiguration und temporäre beziehungsweise containerisierte Datenbank bereitstellen.
2. Schritt 2: Fixtures für Schema, Basissätze und fachliche Szenarien modular aufbauen.
3. Schritt 3: Transaktionen oder Datenbankneuanlage als Isolationsstrategie auswählen.
4. Schritt 4: Constraints, Migrationen und konkurrierende Zugriffe in automatisierten Tests abdecken.

7. pytest-Struktur und Fixtures

Tests erhalten wiederverwendbare, klar begrenzte Setups für Anwendung, Client, CLI und Daten.

1. Schritt 1: Testverzeichnisse und Benennung nach pytest-Konventionen anlegen.
2. Schritt 2: App-Fixture mit TESTING-Konfiguration und sauberem Teardown erstellen.
3. Schritt 3: Client-, Runner- und Daten-Fixtures aus der App-Fixture ableiten.
4. Schritt 4: Fixture-Sichtbarkeit und Scope so klein wie möglich halten.

8. Integrations- und Migrationstests

Zusammenspiel von Anwendung, Datenbank, Queue und Fremdsystemadaptern wird in realitätsnahen Umgebungen überprüft.

1. Schritt 1: Testdatenbank mit produktionsnahem Datenbanktyp bereitstellen.
2. Schritt 2: Migrationen vom leeren Schema bis zum aktuellen Stand ausführen.
3. Schritt 3: Transaktionen, Constraints und Adapter gegen lokale Testdienste prüfen.
4. Schritt 4: Tests isolieren, parallelisierbar machen und Ressourcen zuverlässig abbauen.

9. Datenbank- und ORM-Optimierung

Abfragen werden anhand realer Ausführungspläne und Zugriffsprofile verbessert.

1. Schritt 1: Langsame Abfragen und N+1-Zugriffe über Logging beziehungsweise Tracing identifizieren.
2. Schritt 2: Ladeoptionen, Pagination und gezielte Spaltenauswahl einsetzen.
3. Schritt 3: Indizes aus Filter-, Join- und Sortiermustern ableiten und mit Ausführungsplänen prüfen.
4. Schritt 4: Transaktionsdauer und Poolauslastung unter paralleler Last messen.

Praxisprojekt

Für eine kleine Fachdomäne entstehen Modelle, Beziehungen, Services und Migrationen. Anschließend werden typische Abfragen optimiert, Transaktionsfehler simuliert und der vollständige Datenbankpfad automatisiert getestet.

Methodik

Kurze fachliche Einordnungen wechseln mit Demonstrationen, geführten Umsetzungen, Fehleranalysen und eigenständigen Übungen. Jede größere Änderung wird durch einen Test, eine Diagnose oder eine betriebliche Prüfroutine abgesichert. Die Arbeitsstände werden schrittweise zu einem durchgängigen Beispielprojekt zusammengeführt.