5 Normalformen in Datenbanken, die jeder Entwickler kennen sollte

5 Normalformen in Datenbanken, die jeder Entwickler kennen sollte – mit praktischen Beispielen

Das Verständnis von Normalformen ist für Entwickler entscheidend, um Daten effizient zu strukturieren, Redundanz zu vermeiden, die Wartbarkeit zu erhöhen und die Performance von Datenbanksystemen zu verbessern. In diesem Artikel erklären wir die wichtigsten Normalformen anhand einfacher, praxisnaher Beispiele.

1️⃣ Erste Normalform (1NF)

Die 1NF stellt sicher, dass jede Spalte nur atomare (unteilbare) Werte enthält.

Beispiel: Eine Buchungstabelle, die mehrere Ticketnummern in einer Spalte enthält:

BookingID | CustomerName | Tickets
------------------------------------------
B001      | Ali Ahmed    | T01, T02, T03

Nach der Umwandlung in 1NF:

BookingID | CustomerName | Ticket
------------------------------------------
B001      | Ali Ahmed    | T01
B001      | Ali Ahmed    | T02
B001      | Ali Ahmed    | T03

2️⃣ Zweite Normalform (2NF)

Die 2NF stellt sicher, dass jede Nicht-Schlüssel-Spalte vollständig vom gesamten Primärschlüssel abhängt und nicht nur von einem Teil davon.

Beispiel: Eine Tabelle mit BookingID, Ticket und CustomerName:

BookingID | Ticket | CustomerName
----------------------------------------
B001      | T01    | Ali Ahmed
B001      | T02    | Ali Ahmed

Hier hängt CustomerName nur von BookingID ab und nicht vom zusammengesetzten Schlüssel (BookingID + Ticket).

Nach der Umwandlung in 2NF:

Aufgeteilt in:

Tabelle: Bookings
BookingID | CustomerName
---------------------------
B001      | Ali Ahmed

Tabelle: BookingTickets
BookingID | Ticket
--------------------
B001      | T01
B001      | T02

3️⃣ Dritte Normalform (3NF)

Die 3NF entfernt transitive Abhängigkeiten, sodass Nicht-Schlüssel-Spalten nur vom Primärschlüssel abhängen.

Beispiel: Eine Tabelle mit E-Mail, CustomerName und Country:

Email             | CustomerName | Country
----------------------------------------------
ali@mail.com      | Ali Ahmed    | Jordan

Country hängt von CustomerName ab und nicht direkt von der E-Mail.

Nach der Umwandlung in 3NF:

Tabelle: Customers
Email            | CustomerName
-------------------------------
ali@mail.com     | Ali Ahmed

Tabelle: CustomerCountries
CustomerName | Country
-------------------------
Ali Ahmed    | Jordan

4️⃣ Boyce-Codd Normalform (BCNF)

BCNF stärkt die 3NF, indem sichergestellt wird, dass jede Spalte, die eine andere bestimmt, ein Kandidatenschlüssel sein muss.

Beispiel: Eine Kursbelegungstabelle:

CourseID | Room | Instructor
-------------------------------
C101     | R1   | Dr Omar
C102     | R2   | Dr Samir

Wenn jeder Raum einem bestimmten Dozenten zugeordnet ist, bestimmt Room den Instructor.

Nach der Umwandlung in BCNF:

Tabelle: RoomInstructor
Room | Instructor
---------------------
R1   | Dr Omar
R2   | Dr Samir

Tabelle: CourseRoom
CourseID | Room
-----------------
C101     | R1
C102     | R2

5️⃣ Vierte Normalform (4NF)

Die 4NF stellt sicher, dass eine Tabelle keine unabhängigen 1:n-Beziehungen für dieselbe Entität enthält.

Beispiel: Eine Mitarbeitertabelle mit Skills und Projekten:

EmployeeID | Skill   | Project
---------------------------------
E001       | Python  | P01
E001       | Java    | P01
E001       | Python  | P02

Nach der Umwandlung in 4NF:

Tabelle: EmployeeSkills
EmployeeID | Skill
-----------------------
E001       | Python
E001       | Java

Tabelle: EmployeeProjects
EmployeeID | Project
------------------------
E001       | P01
E001       | P02

📌 Fazit

Das Erlernen und Anwenden von Normalformen stellt sicher, dass Datenbanken sauber, wartbar und effizient bleiben, wodurch Redundanz reduziert und die Performance von Anwendungen langfristig verbessert wird.

Wenn dir dieser Artikel gefallen hat und du mehr praxisnahe Tutorials für Entwickler wünschst, folge mir gerne für weitere hochwertige Artikel rund um Datenbanken und Backend-Entwicklung.