FastAPI ist ein modernes, schnelles (High-Performance) Web-Framework für Python, das speziell für die Entwicklung von APIs entwickelt wurde. Es basiert auf Python 3.6+, Starlette (für Web-Handling) und Pydantic (für Datenvalidierung und -serialisierung).
✅ Schnell – FastAPI ist eine der schnellsten verfügbaren Python-Frameworks, vergleichbar mit NodeJS oder Go (dank uvicorn
und Starlette
).
✅ Automatische Dokumentation – Es generiert automatisch interaktive API-Dokumentationen über Swagger UI und ReDoc.
✅ Typsicherheit – Durch Typannotationen erkennt FastAPI automatisch Eingaben, prüft sie und erstellt automatisch Dokumentation.
✅ Asynchron / Async Support – Native Unterstützung für async
/await
für hohe Performance bei I/O-lastigen Anwendungen (z. B. Datenbankanfragen).
✅ Einfache Nutzung – FastAPI ist einfach zu lernen, besonders wenn man bereits Erfahrung mit Python und Typannotationen hat.
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hallo Welt"}
Wenn du das startest (z. B. mit uvicorn main:app --reload
), läuft ein Webserver und unter http://localhost:8000/docs
findest du direkt eine interaktive API-Doku.
RESTful APIs
Backend für Web- oder Mobile-Apps
Microservices
Datenverarbeitung und Machine Learning APIs
Datenbank-Trigger (kurz: Trigger) sind spezielle automatische Aktionen in einer Datenbank, die ausgelöst werden, wenn bestimmte Ereignisse auf einer Tabelle oder Sicht (View) passieren.
Ein Trigger ist ein vordefinierter Code, der bei INSERT, UPDATE oder DELETE auf einer Tabelle automatisch ausgeführt wird – ohne dass der Benutzer ihn direkt aufruft.
Stell dir vor, du hast eine Tabelle Bestellungen
, und du willst, dass immer, wenn eine Bestellung gelöscht wird, diese Info in einer Tabelle Log
gespeichert wird.
Dann schreibst du einen DELETE-Trigger für die Tabelle Bestellungen
, der automatisch beim Löschen etwas in Log
schreibt.
Typ | Beschreibung |
---|---|
BEFORE | Wird vor der Aktion ausgeführt |
AFTER | Wird nach der Aktion ausgeführt |
INSTEAD OF | (bei Views) ersetzt die Aktion komplett |
CREATE TRIGGER log_delete
AFTER DELETE ON Bestellungen
FOR EACH ROW
BEGIN
INSERT INTO Log (aktion, zeitpunkt)
VALUES ('Bestellung gelöscht', NOW());
END;
Validierung von Daten
Automatisches Logging
Business-Logik abbilden
Referentielle Integrität erweitern
Schwer zu debuggen
Können unbemerkt viele Aktionen auslösen
Beeinflussen Performance, wenn komplex
Docker Compose ist ein Werkzeug, mit dem du mehrere Docker-Container als einen einzigen Service definieren und starten kannst. Statt jeden Container einzeln über die Docker-CLI zu starten, kannst du mit Docker Compose eine docker-compose.yml
-Datei schreiben, in der du alle benötigten Dienste (z. B. Datenbank, Webserver, App-Container) deklarierst.
Docker Compose = Projektbeschreibung + Mehrere Container + Ein Befehl zum Starten
docker-compose.yml
version: '3.9'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/code
redis:
image: "redis:alpine"
In diesem Beispiel:
Ein Container baut die lokale Webanwendung.
Ein zweiter Container nutzt das offizielle Redis-Image.
Beide Container sind miteinander vernetzt.
docker-compose up # Startet alle Container im Vordergrund
docker-compose up -d # Startet im Hintergrund (detached)
docker-compose down # Stoppt und entfernt Container, Netzwerke etc.
✅ Einfaches Setup für Multi-Container-Anwendungen
✅ Alles wird in einer Datei versioniert (z. B. für Git)
✅ Reproduzierbare Entwicklungsumgebungen
✅ Leichtes Hoch- und Runterfahren ganzer Stacks
Lokale Entwicklung mit mehreren Services (z. B. App + DB)
Integrationstests mit vollständigem Stack
Simpler Deployment-Workflow (z. B. über CI/CD)
Ein Prepared Statement (auch vorbereitetes Statement genannt) ist eine Technik in der Programmierung, insbesondere bei der Arbeit mit Datenbanken, um SQL-Abfragen sicherer und effizienter auszuführen.
Ein Prepared Statement besteht aus zwei Schritten:
Vorbereitung der SQL-Abfrage mit Platzhaltern
Beispiel in SQL:
SELECT * FROM users WHERE username = ? AND password = ?
(In manchen Sprachen nutzt man auch :username
oder andere Platzhalter)
Bindung der Parameter und Ausführung
Die echten Werte werden später „gebunden“, z. B.:
$stmt->bind_param("ss", $username, $password);
$stmt->execute();
✅ Sicherer vor SQL-Injection:
Benutzereingaben werden nicht direkt in die SQL eingebaut, sondern separat behandelt.
✅ Schneller bei Wiederholungen:
Die SQL-Abfrage wird vom Datenbankserver einmal geparst und kann mehrfach effizient ausgeführt werden (z. B. bei Schleifen).
$conn = new mysqli("localhost", "user", "pass", "database");
$stmt = $conn->prepare("SELECT * FROM users WHERE email = ?");
$stmt->bind_param("s", $email); // "s" für string
$email = "beispiel@example.com";
$stmt->execute();
$result = $stmt->get_result();
Ein Prepared Statement trennt SQL-Logik von Benutzereingaben und schützt so vor Sicherheitslücken wie SQL-Injection. Es ist eine Best Practice beim Umgang mit Datenbanken.
Ein Outer Join ist ein Begriff aus der Datenbankabfrage (meist in SQL) und bezeichnet eine spezielle Art, zwei Tabellen miteinander zu verknüpfen – auch dann, wenn keine passenden Datensätze in einer der Tabellen vorhanden sind.
LEFT OUTER JOIN (oder einfach: LEFT JOIN):
→ Gibt alle Datensätze aus der linken Tabelle zurück, auch wenn es keine passenden Datensätze in der rechten Tabelle gibt.
→ Nicht passende Werte aus der rechten Tabelle werden mit NULL
aufgefüllt.
RIGHT OUTER JOIN (oder: RIGHT JOIN):
→ Gibt alle Datensätze aus der rechten Tabelle zurück, auch wenn es keine passenden in der linken gibt.
→ Nicht passende Werte aus der linken Tabelle werden mit NULL
ergänzt.
FULL OUTER JOIN:
→ Gibt alle Datensätze aus beiden Tabellen zurück.
→ Wo keine Übereinstimmung vorliegt, wird mit NULL
ergänzt.
Angenommen, du hast zwei Tabellen:
Kunden
Kundennr | Name |
1 | Anna |
2 | Bernd |
3 | Clara |
Bestellungen
Bestellnr | Kundennr | Produkt |
101 | 2 | Buch |
102 | 4 | Lampe |
Kundennr | Name | Bestellnr | Produkt |
---|---|---|---|
1 | Anna | NULL | NULL |
2 | Bernd | 101 | Buch |
3 | Clara | NULL | NULL |
PDO steht für PHP Data Objects und ist eine Datenbank-Abstraktionsschicht in PHP. Es handelt sich um eine objektorientierte Schnittstelle, mit der du auf verschiedene Datenbanken zugreifen kannst – z. B. MySQL, PostgreSQL, SQLite – ohne den Datenbankspezifischen Code stark ändern zu müssen.
✅ Einheitliche API:
Egal ob MySQL, SQLite oder PostgreSQL – du benutzt denselben Code-Stil.
✅ Prepared Statements:
Sicherer Schutz vor SQL-Injektionen durch gebundene Parameter:
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = :id");
$stmt->execute(['id' => $userId]);
✅ Transaktionen:
PDO unterstützt Transaktionen (wichtig z. B. bei Bankbuchungen).
✅ Fehlerbehandlung per Exception:
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
✅ Flexibler Datenbankwechsel:
Möchtest du von MySQL auf PostgreSQL wechseln? Meist nur der DSN-String und Treiber müssen geändert werden.
$dsn = 'mysql:host=localhost;dbname=testdb;charset=utf8mb4';
$user = 'root';
$pass = '';
try {
$pdo = new PDO($dsn, $user, $pass);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
echo "Verbindung erfolgreich!";
} catch (PDOException $e) {
echo "Verbindung fehlgeschlagen: " . $e->getMessage();
}
PDO ist der empfohlene Weg, um in modernen PHP-Anwendungen mit Datenbanken zu arbeiten – besonders wegen der Sicherheit und Flexibilität.
Transaction Control Language (TCL) ist ein Teil der SQL-Sprache, der verwendet wird, um die Kontrolle über Transaktionen in einer Datenbank zu ermöglichen. Eine Transaktion ist eine logische Einheit von Arbeit, die eine oder mehrere SQL-Anweisungen umfasst – oft Insert-, Update- oder Delete-Befehle –, die zusammen ausgeführt werden sollen.
TCL stellt Befehle bereit, um sicherzustellen, dass Transaktionen korrekt abgeschlossen oder im Fehlerfall rückgängig gemacht werden.
Befehl | Beschreibung |
---|---|
COMMIT |
Speichert alle Änderungen der aktuellen Transaktion dauerhaft in der Datenbank. |
ROLLBACK |
Macht alle Änderungen seit dem letzten COMMIT rückgängig. |
SAVEPOINT |
Legt einen Zwischenstand in einer Transaktion fest, zu dem man später zurückkehren kann. |
ROLLBACK TO SAVEPOINT |
Macht alle Änderungen seit einem bestimmten Savepoint rückgängig. |
SET TRANSACTION |
Legt Eigenschaften für eine Transaktion fest (z. B. Isolationsgrad). |
BEGIN;
UPDATE konto SET saldo = saldo - 100 WHERE konto_id = 1;
UPDATE konto SET saldo = saldo + 100 WHERE konto_id = 2;
COMMIT;
→ Beide Updates werden gemeinsam abgeschlossen. Wenn ein Fehler auftritt, könnte man ROLLBACK
ausführen, um beide Änderungen zu verwerfen.
TCL-Befehle wirken nur bei Datenbank-Systemen, die Transaktionen unterstützen (z. B. PostgreSQL, Oracle, MySQL mit InnoDB).
Data Control Language (DCL) ist ein Teilbereich von SQL, der sich mit der Verwaltung von Zugriffsrechten und Berechtigungen in einer Datenbank beschäftigt. Mit DCL-Befehlen wird gesteuert, wer was in der Datenbank tun darf.
Befehl | Beschreibung |
---|---|
GRANT |
Erteilt einem Benutzer Rechte, z. B. zum Lesen oder Ändern von Daten |
REVOKE |
Entzieht einem Benutzer zuvor erteilte Rechte |
GRANT SELECT, INSERT ON Kunden TO Benutzer123;
REVOKE INSERT ON Kunden FROM Benutzer123;
SELECT
– Daten lesen
INSERT
– Daten einfügen
UPDATE
– Daten ändern
DELETE
– Daten löschen
ALL
– Alle Rechte
DCL regelt Sicherheit und Zugriffskontrolle in der Datenbank.
Sie wird meist vom Datenbankadministrator (DBA) verwendet.
Die Rechte können auf Tabellenebene, Spaltenebene oder global vergeben werden.
Änderungen durch DCL-Befehle sind oft transaktionsabhängig und benötigen ggf. ein COMMIT
.
DDL: Datenbankstruktur (z. B. Tabellen erstellen)
DML: Dateninhalte (z. B. Daten einfügen oder ändern)
TCL: Transaktionen steuern (z. B. COMMIT
, ROLLBACK
)
DCL: Rechte und Zugriffe verwalten
DQL steht für Data Query Language und ist ein Teil der SQL-Sprache (Structured Query Language). Sie dient dazu, Daten aus einer Datenbank abzufragen, ohne sie zu verändern.
Nur lesend: Mit DQL werden Daten abgefragt, aber nicht eingefügt, verändert oder gelöscht.
Der zentral verwendete Befehl ist:
SELECT
Beispiel:
SELECT name, geburtsdatum FROM kunden WHERE stadt = 'Berlin';
Dieser Befehl liest die Namen und Geburtsdaten aller Kunden aus, die in Berlin wohnen – verändert aber nichts an den Daten.
Teil | Bedeutung | Hauptfunktion |
---|---|---|
DQL | Data Query Language | Daten lesen |
DML | Data Manipulation Language | Daten einfügen, ändern, löschen (INSERT , UPDATE , DELETE ) |
DDL | Data Definition Language | Tabellen und Strukturen definieren (CREATE , ALTER , DROP ) |
DCL | Data Control Language | Rechte vergeben (GRANT , REVOKE ) |
TCL | Transaction Control Language | Transaktionen steuern (COMMIT , ROLLBACK ) |
Ein Entity Manager ist ein zentraler Bestandteil von ORM-Frameworks (Object-Relational Mapping), vor allem im Zusammenhang mit Java (JPA – Java Persistence API), aber auch in anderen Sprachen wie PHP (Doctrine ORM).
Hier ist eine verständliche Erklärung:
Ein Entity Manager ist eine Komponente, die sich um die Verwaltung von Datenbank-Entities (also Objekten/Datensätzen) kümmert. Er bildet die Schnittstelle zwischen der objektorientierten Welt des Codes und der relationalen Welt der Datenbank.
Persistieren (Speichern):
Finden/Laden:
Holt ein Objekt anhand seiner ID oder anderer Kriterien.
Beispiel: $entityManager->find(User::class, 1);
Aktualisieren:
Änderungen an einem Objekt werden verfolgt und in die Datenbank geschrieben (z. B. beim flush()
).
Entfernen/Löschen:
Löscht ein Objekt aus der Datenbank.
Beispiel: $entityManager->remove($user);
Transaktionen verwalten:
Beginnt, commitet oder rollt Transaktionen zurück.
Query-Handling:
Führt eigene Abfragen aus, oft mit DQL (Doctrine Query Language) oder JPQL.
Der Entity Manager verwaltet den „Zustand“ von Objekten:
managed (verfolgt Änderungen),
detached (nicht mehr verwaltet),
removed (zum Löschen markiert),
new (noch nicht gespeichert).
$user = new User();
$user->setName('Max Mustermann');
$entityManager->persist($user); // Zum Speichern vormerken
$entityManager->flush(); // Tatsächlich in DB schreiben
Der Entity Manager ist der zentrale Ansprechpartner, wenn es darum geht, mit Datenbankobjekten zu arbeiten – lesen, schreiben, ändern, löschen. Er abstrahiert die SQL-Ebene und macht die Datenbankarbeit objektorientiert steuerbar.