05 · Datenbank-Abfragen mit SQL

Klinischer Aufhänger

Das Rechenzentrum gibt dir schreibgeschützten Zugriff auf die Klinikdatenbank, nur per SQL-Abfrage. Um die Frage „Unterscheidet sich das mittlere Laktat je nach Aufnahmegrund?“ zu beantworten, musst du kohorte und labor verbinden und gruppiert aggregieren. Mit SQL geht das in vier Zeilen.

1 Relationales Denken

Eine relationale Datenbank speichert Daten in mehreren Tabellen. Jede Tabelle hat einen Primärschlüssel (eindeutige ID je Zeile). Tabellen werden über Fremdschlüssel verknüpft.

In unserem Datensatz ist patient_id der gemeinsame Schlüssel zwischen kohorte.csv, labor.csv und vitalwerte.csv.

Mit DuckDB führst du SQL direkt auf CSV-Dateien aus, ohne Datenbankserver, ideal zum Erkunden.

2 SELECT, WHERE, ORDER BY

Die grundlegendste SQL-Abfrage:

SELECT patient_id, alter, aufnahmegrund, sofa_score
FROM kohorte
WHERE aufnahmegrund = 'Sepsis'
  AND sofa_score >= 6
ORDER BY sofa_score DESC
LIMIT 10;

• SELECT – welche Spalten?
• FROM – aus welcher Tabelle?
• WHERE – welche Zeilen? (Bedingungen mit AND, OR, NOT)
• ORDER BY – sortieren (Standard: aufsteigend, DESC für absteigend)
• LIMIT – maximale Zeilenzahl

DuckDB öffnet eine Web-Adresse nur über seine Erweiterung httpfs (siehe Fallstricke). Einfacher registrierst du ein pandas-DataFrame oder R-data.frame, das du zuvor ganz normal (Modul 04) geladen hast. Das Muster in diesem Modul ist deshalb: erst mit pandas/readr von https://datascience.medizin.dev/data/ laden, dann bei DuckDB registrieren. Die con-Verbindung aus diesem Abschnitt bleibt für den Rest des Moduls offen, alle folgenden Abfragen bauen darauf auf.

import duckdb
import pandas as pd

cohort = pd.read_csv("https://datascience.medizin.dev/data/kohorte.csv")
labor  = pd.read_csv("https://datascience.medizin.dev/data/labor.csv")

con = duckdb.connect(":memory:")
con.register("kohorte", cohort)
con.register("labor", labor)

result = con.execute("""
    SELECT patient_id, alter, aufnahmegrund, sofa_score
    FROM kohorte
    WHERE aufnahmegrund = 'Sepsis'
      AND sofa_score >= 6
    ORDER BY sofa_score DESC
    LIMIT 10
""").df()
print(result)

library(DBI)
library(duckdb)
library(readr)

cohort <- read_csv("https://datascience.medizin.dev/data/kohorte.csv", show_col_types = FALSE)
labor  <- read_csv("https://datascience.medizin.dev/data/labor.csv", show_col_types = FALSE)

con <- dbConnect(duckdb::duckdb(), dbdir = ":memory:")
duckdb::duckdb_register(con, "kohorte", cohort)
duckdb::duckdb_register(con, "labor", labor)

result <- dbGetQuery(con, "
  SELECT patient_id, alter, aufnahmegrund, sofa_score
  FROM kohorte
  WHERE aufnahmegrund = 'Sepsis'
    AND sofa_score >= 6
  ORDER BY sofa_score DESC
  LIMIT 10
")
print(result)

3 Aggregation mit GROUP BY

Aggregatfunktionen fassen mehrere Zeilen zusammen:

GROUP BY teilt die Tabelle in Gruppen auf, bevor die Aggregatfunktion angewendet wird. HAVING filtert anschließend auf Gruppenebene (analog zu WHERE, aber nach der Aggregation).

SELECT
    aufnahmegrund,
    COUNT(*)               AS anzahl,
    ROUND(AVG(sofa_score), 1) AS sofa_mittel,
    ROUND(AVG(verstorben_30d) * 100, 1) AS mortalitaet_pct
FROM kohorte
GROUP BY aufnahmegrund
HAVING COUNT(*) >= 50
ORDER BY mortalitaet_pct DESC;

4 JOIN: Tabellen verbinden

Ein JOIN verbindet zwei Tabellen über einen gemeinsamen Schlüssel:

SELECT k.patient_id, k.aufnahmegrund, k.alter, l.laktat_mmol_l
FROM kohorte  AS k
LEFT JOIN labor AS l ON k.patient_id = l.patient_id
WHERE l.laktat_mmol_l IS NOT NULL;

Achtung: Die WHERE-Bedingung auf eine Spalte der rechten Tabelle wirft die NULL-Zeilen wieder hinaus; das Ergebnis gleicht damit einem INNER JOIN auf gemessene Werte (414 statt 500 Zeilen). Hier ist das gewollt, weil nur gemessene Laktatwerte interessieren. Sollen alle Patient:innen erhalten bleiben, gehört die Bedingung in die ON-Klausel oder entfällt.

Faustregel: In der klinischen Forschung fast immer LEFT JOIN: du willst alle Patient:innen behalten, auch wenn ein Laborwert fehlt.

Der vollständige Code mit allen Abfragen steht in code/sql.sql, code/python.py und code/r.R.

5 Abfragen kombinieren

SQL-Abfragen können verschachtelt werden (Subqueries) oder mit WITH als Common Table Expressions (CTEs) lesbar strukturiert werden:

-- CTE: first identify Sepsis patients, then evaluate their lactate
WITH sepsis_pts AS (
    SELECT patient_id
    FROM kohorte
    WHERE aufnahmegrund = 'Sepsis'
)
SELECT
    ROUND(AVG(l.laktat_mmol_l), 2) AS laktat_mittel,
    COUNT(*)                         AS n
FROM labor AS l
INNER JOIN sepsis_pts AS s ON l.patient_id = s.patient_id
WHERE l.laktat_mmol_l IS NOT NULL;

Fallstricke und Merksätze

• NULL ist nicht 0. WHERE laktat IS NOT NULL explizit formulieren. Aggregatfunktionen ignorieren NULL automatisch, aber COUNT(*) zählt alle Zeilen, COUNT(spalte) nur Nicht-NULL-Werte.

• LEFT JOIN vs. INNER JOIN: Ein INNER JOIN auf labor schließt Patient:innen ohne Laborzeile still aus; in einer klinischen Kohorte ist das fast immer ein Fehler.

• Reihenfolge der Klauseln: geschrieben wird SELECT → FROM → WHERE → GROUP BY → HAVING → ORDER BY → LIMIT, ausgewertet aber FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT. Deshalb prüft SQL HAVING erst nach dem Gruppieren, und ein Alias aus SELECT taugt in ORDER BY, in WHERE aber nicht.

• DuckDB und Daten: Ein DataFrame erst mit pandas/readr laden (auch von einer Web-Adresse) und dann mit con.register() / duckdb_register() sichtbar machen, keine Datei nötig. Alternativ liest DuckDBs read_csv_auto() auch direkt CSV-Pfade, lokal ohne Zusatzschritt, von einer URL über die Erweiterung httpfs. Neuere DuckDB-Versionen laden sie beim ersten Zugriff automatisch nach, brauchen dafür aber Internet; sonst einmalig INSTALL httpfs; LOAD httpfs;.

• Spaltenaliase (AS anzahl) verbessern Lesbarkeit und sind in ORDER BY referenzierbar.

Selbstcheck