Flask & Database

6 Kernkonzepte

Die wichtigsten Konzepte für Datenbankintegration in Flask: SQLAlchemy · Models · Queries · Relationships · Flask-Migrate · CRUD Flask arbeitet mit SQLAlchemy als ORM für die Datenbankanbindung. Diese Cheatsheet fasst die grundlegenden Konzepte für Models, Queries, Beziehungen und Migrationen zusammen.

Setup & Konfiguration – SQLAlchemy initialisieren

SQLALCHEMY_DATABASE_URI · SQLALCHEMY_TRACK_MODIFICATIONS

# requirements.txt flask-sqlalchemy flask-migrate # app.py from flask_sqlalchemy import SQLAlchemy app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' db = SQLAlchemy(app)

SQLAlchemy ist das ORM (Object-Relational Mapper) für Flask. Es abstrahiert die Datenbankzugriffe und ermöglicht die Arbeit mit Python-Objekten statt SQL.

Beispiele

# app.py

from flask import Flask

from flask_sqlalchemy import SQLAlchemy

from flask_migrate import Migrate

app = Flask(__name__)

# Datenbank-Konfiguration

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db'

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# PostgreSQL

# app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://user:pass@localhost/dbname'

# MySQL

# app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://user:pass@localhost/dbname'

db = SQLAlchemy(app)

migrate = Migrate(app, db)

Tipp: SQLite ist ideal für Entwicklung und Tests. Für Produktion sollten Sie PostgreSQL oder MySQL verwenden. Setzen Sie SQLALCHEMY_TRACK_MODIFICATIONS = False für bessere Performance.

Models – Datenbanktabellen als Python-Klassen

db.Model · Column · Integer · String · DateTime

class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), nullable=False) email = db.Column(db.String(100), unique=True)

Models sind Python-Klassen, die Datenbanktabellen repräsentieren. Jede Klasse erbt von db.Model, Attribute werden als db.Column definiert.

Wichtige Column-Typen

Typ	Beschreibung
db.Integer	Ganzzahl
db.String(length)	Zeichenkette (VARCHAR)
db.Text	Langer Text
db.Boolean	Wahrheitswert
db.DateTime	Datum und Uhrzeit
db.Date	Datum
db.Float	Gleitkommazahl
db.JSON	JSON-Daten (PostgreSQL/MySQL)

Beispiele

# models.py

from app import db

class User(db.Model):

id = db.Column(db.Integer, primary_key=True)

username = db.Column(db.String(80), unique=True, nullable=False)

email = db.Column(db.String(120), unique=True, nullable=False)

created_at = db.Column(db.DateTime, default=db.func.now())

is_active = db.Column(db.Boolean, default=True)

# __repr__ für Debugging

def __repr__(self):

return f'<User {self.username}>'

# Post-Modell mit Fremdschlüssel

class Post(db.Model):

id = db.Column(db.Integer, primary_key=True)

title = db.Column(db.String(200), nullable=False)

content = db.Column(db.Text, nullable=False)

user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

Tipp: Verwenden Sie db.relationship() für Beziehungen zwischen Models (siehe nächste Karte). __repr__ ist hilfreich für Debugging in der Shell.

Queries & Filter – Daten abfragen

Model.query · filter · filter_by · order_by · first · all

users = User.query.all() user = User.query.filter_by(username='anna').first() users = User.query.filter(User.email.like('%@example.com')).all()

Queries werden über das query-Attribut des Models ausgeführt. Sie können filtern, sortieren, begrenzen und verknüpfen.

Häufige Query-Methoden

Methode	Beschreibung
all()	Alle Treffer als Liste
first()	Ersten Treffer oder None
first_or_404()	Ersten Treffer oder 404-Fehler
get(id)	Eintrag nach Primärschlüssel
get_or_404(id)	Eintrag oder 404-Fehler
count()	Anzahl der Treffer
order_by()	Sortierung
limit()	Anzahl der Ergebnisse begrenzen
offset()	Ergebnisse überspringen (Paginierung)

Beispiele

# Alle Benutzer

users = User.query.all()

# Benutzer nach ID

user = User.query.get(1)

# Filter mit filter_by (einfach)

user = User.query.filter_by(username='max').first()

# Filter mit filter (flexibel)

users = User.query.filter(User.email.like('%@gmail.com')).all()

# Sortierung (absteigend)

users = User.query.order_by(User.created_at.desc()).all()

# Paginierung (Seite 2, 10 Einträge pro Seite)

page = User.query.paginate(page=2, per_page=10, error_out=False)

# Kombinierte Filter

users = User.query.filter(

User.is_active == True,

User.created_at > datetime(2023, 1, 1)

).order_by(User.username).all()

Tipp: Verwenden Sie first_or_404() und get_or_404() in View-Funktionen, um automatisch einen 404-Fehler zu werfen, wenn der Eintrag nicht existiert.

Beziehungen – One-to-Many, Many-to-Many

db.relationship · backref · secondary

# One-to-Many (User → Posts) posts = db.relationship('Post', backref='author', lazy='dynamic') # Many-to-Many (User ↔ Roles) roles = db.relationship('Role', secondary='user_roles', backref='users')

Beziehungen verbinden Tabellen miteinander. SQLAlchemy unterstützt One-to-Many, Many-to-One, One-to-One und Many-to-Many.

Beispiele

# One-to-Many (User hat viele Posts)

class User(db.Model):

# ... Spalten ...

posts = db.relationship('Post', backref='author', lazy='dynamic')

# Many-to-Many (User ↔ Roles mit Assoziationstabelle)

# Assoziationstabelle

user_roles = db.Table('user_roles',

db.Column('user_id', db.Integer, db.ForeignKey('user.id')),

db.Column('role_id', db.Integer, db.ForeignKey('role.id'))

)

class Role(db.Model):

id = db.Column(db.Integer, primary_key=True)

name = db.Column(db.String(50), unique=True)

users = db.relationship('User', secondary='user_roles', backref='roles')

# Verwendung

user = User.query.first()

# Posts des Benutzers

posts = user.posts.all()

# Autor eines Posts

author = post.author

# Rollen des Benutzers

roles = user.roles

Tipp: lazy='dynamic' gibt einen Query-Objekt zurück, das weiter gefiltert werden kann (z.B. user.posts.filter_by(title='...')). Ohne lazy wird die Liste direkt geladen.

Migrationen – Datenbank-Schema ändern

flask db init · flask db migrate · flask db upgrade

# Migration initialisieren flask db init # Migration erstellen flask db migrate -m "Nachricht" # Migration ausführen flask db upgrade # Letzte Migration rückgängig flask db downgrade

Flask-Migrate ist eine Erweiterung für SQLAlchemy, die Datenbank-Migrationen ermöglicht – basierend auf Alembic.

Beispiele

# Terminal-Befehle

# 1. Migration initialisieren (einmalig)

flask db init

# 2. Migration erstellen (nach Änderungen an Models)

flask db migrate -m "Benutzer-Tabelle hinzugefügt"

# 3. Migration ausführen

flask db upgrade

# 4. Migration rückgängig machen (eine Stufe)

flask db downgrade

# 5. Aktuellen Status anzeigen

flask db current

# 6. History anzeigen

flask db history

# 7. Migrationsskript anzeigen

flask db show

# 8. Datenbank löschen (Vorsicht!)

flask db drop

# 9. Datenbank erstellen (basierend auf Models)

flask db create

# 10. Datenbank neu erstellen (migrate + upgrade)

flask db reset # Nicht standardmäßig – eigener Befehl

Tipp: Überprüfen Sie immer die generierten Migrationsskripte in migrations/versions/, bevor Sie upgrade ausführen – besonders bei komplexen Änderungen oder Datenbank-Systemen.

CRUD-Operationen – Create, Read, Update, Delete

db.session.add · db.session.commit · db.session.delete

# CREATE user = User(username='max', email='max@example.com') db.session.add(user) db.session.commit() # UPDATE user.email = 'neu@example.com' db.session.commit() # DELETE db.session.delete(user) db.session.commit()

CRUD-Operationen sind die Grundoperationen für Datenbankzugriffe: Create, Read, Update, Delete. Alle Änderungen werden über die Session gesteuert.

Beispiele

# CREATE – Neuen Benutzer anlegen

def create_user(username, email):

user = User(username=username, email=email)

db.session.add(user)

db.session.commit()

return user

# READ – Benutzer abrufen

user = User.query.first()

# UPDATE – Benutzer aktualisieren

def update_user(user_id, new_email):

user = User.query.get(user_id)

if user:

user.email = new_email

db.session.commit()

return user

# DELETE – Benutzer löschen

def delete_user(user_id):

user = User.query.get(user_id)

if user:

db.session.delete(user)

db.session.commit()

return True

# CREATE – Mehrere Einträge auf einmal

users = [

User(username='user1', email='user1@example.com'),

User(username='user2', email='user2@example.com')

]

db.session.add_all(users)

db.session.commit()

Tipp: Verwenden Sie db.session.commit() nach allen Änderungen. Bei Fehlern können Sie db.session.rollback() verwenden, um die Änderungen rückgängig zu machen.

Flask & Database im Überblick

db.Model Model-Klasse
Tabelle definieren

db.Column Tabellenspalte
Typ, Constraints

query Daten abfragen
filter, order_by, all

relationship Beziehungen
One-to-Many, Many-to-Many

db.session CRUD-Operationen
add, commit, delete

flask db Migrationen
migrate, upgrade, downgrade

Quick Summary

SQLALCHEMY

Setup

db.Model

Models

query

Queries

relationship

Beziehungen

flask db

Migrationen

session

CRUD

db.session.add(obj) · db.session.commit() · Model.query.filter_by(...).first()