Daten aktualisieren mit UPDATE

Heute nehmen wir uns einen weiteren wichtigen Baustein für dein neues SQL-Wissen vor – das Aktualisieren von Daten. Wir schauen uns an, wie du in PostgreSQL bestehende Infos mit dem Befehl UPDATE änderst. Warum ist das wichtig? Na ja, in der echten Welt sind Daten nie statisch. Stell dir vor, dein Kumpel hat seine Telefonnummer geändert oder ein Student ist in eine andere Gruppe gewechselt – klar willst du das in deiner Datenbank anpassen.

Wenn deine Schul-Liebe Swetka Sokolova plötzlich zu Swetka Chatschatourjan wird (so spielt halt das Leben), dann muss das natürlich auch in deiner Datenbank geändert werden. Solche Szenarien, in denen Daten aktualisiert werden müssen, kommen ständig vor:

• Fehler in einem Datensatz korrigieren.
• Infos aktualisieren (Umzug, Statusänderung).
• Massenänderungen, zum Beispiel Gehaltserhöhungen für Mitarbeitende.

Daten aktualisieren heißt: Du änderst die Werte von einer oder mehreren Spalten für eine oder mehrere Zeilen in einer Tabelle, ohne neue Einträge hinzuzufügen.

Syntax von UPDATE

Der UPDATE-Befehl in PostgreSQL ist ziemlich easy zu verstehen. Hier die Struktur:

UPDATE tabelle
SET spalte1 = wert1,
    spalte2 = wert2
WHERE bedingung;

Erklärung:

• tabelle: Der Name der Tabelle, in der du was ändern willst.
• SET spalte = wert: Gibt an, welche Spalte du mit welchem Wert ändern willst.
• WHERE bedingung: Die Bedingung legt fest, welche Zeilen aktualisiert werden (super wichtig, damit du nicht alles änderst!).

Wichtiges Detail: Wenn du WHERE vergisst (oder falsch schreibst), betrifft deine Änderung alle Zeilen in der Tabelle. Das kann richtig böse enden.

Beispiel: Name eines Studenten ändern

Angenommen, wir haben eine Tabelle students mit den Spalten id, name, email. Wir wollen den Namen des Studenten mit id = 1 auf "Maria Chi" ändern.

UPDATE students
SET name = 'Maria Chi'
WHERE id = 1;

Dieser Befehl sucht die Zeile mit id = 1 und setzt die Spalte name auf den neuen Wert. Easy, oder?

Mehrere Spalten aktualisieren

Oft willst du gleich mehrere Werte in einem Datensatz ändern. Zum Beispiel, wenn ein Student nicht nur seinen Namen, sondern auch seine E-Mail-Adresse geändert hat. So geht’s:

UPDATE students
SET name = 'Otto Lin',
    email = 'otto.lin@example.com'
WHERE id = 2;

Hier aktualisieren wir sowohl name als auch email für den Studenten mit id = 2. PostgreSQL erlaubt dir, mehrere spalte=wert-Paare durch Kommas im SET-Teil zu trennen.

Mehrere Zeilen aktualisieren

Was, wenn du gleich mehrere Zeilen ändern willst? Zum Beispiel willst du eine ganze Gruppe von Studenten in einen neuen Kurs verschieben. Dafür kannst du alle Zeilen aktualisieren, die einem bestimmten Kriterium entsprechen. Angenommen, wir haben das Feld group_number und wollen alle Studenten aus Gruppe 101 in Gruppe 202 verschieben:

UPDATE students
SET group_number = 202
WHERE group_number = 101;

Dieser Befehl aktualisiert alle Zeilen, bei denen group_number gleich 101 ist, und setzt sie auf 202.

5. Die WHERE-Bedingung: Sei vorsichtig!

Wie schon gesagt: WHERE ist dein Rettungsring. Ohne das betrifft dein Befehl alle Zeilen der Tabelle. Zum Beispiel würde der folgende Befehl die GRUPPE aller Studenten ändern, nicht nur die der Gruppe 101. Das willst du garantiert nicht:

UPDATE students
SET group_number = 202;

Bitte immer WHERE benutzen, wenn du nicht aus Versehen alles zerschießen willst. Lieber einmal zu viel als zu wenig absichern.

Denk an UPDATE als einen Befehl, der Spalten einer Tabelle ändert, nicht die Zeilen. Ziel ist es, bestimmten Zellen einer Spalte einen bestimmten Wert zu geben. Erst durch WHERE werden nicht alle Zeilen geändert.

Update mit Daten aus einer anderen Tabelle

Manchmal willst du nicht einfach einen Wert „von Hand“ eintragen, sondern Werte in Tabelle A mit Daten aus Tabelle B aktualisieren. Das kommt oft vor – zum Beispiel, wenn Berechnungen in einer Tabelle stehen und User-Profile in einer anderen.

Angenommen, wir haben eine Tabelle students, in der wir die Spalte debt mit Werten aus der Tabelle payments aktualisieren wollen, wo der aktuelle Schuldenstand (due_amount) steht. Jeder Eintrag in students hat einen passenden Eintrag in payments über das Feld student_id.

Die Syntax sieht so aus:

UPDATE students
SET debt = payments.due_amount
FROM payments
WHERE students.id = payments.student_id;

Was passiert hier:

• PostgreSQL nutzt FROM payments als Datenquelle.
• Über die WHERE-Bedingung werden die Zeilen zwischen den Tabellen verknüpft.
• Es werden nur die students-Zeilen aktualisiert, für die es ein passendes payments-Match gibt.

Wichtig zu verstehen: In diesem UPDATE ... FROM läuft im Hintergrund quasi ein JOIN – nur ohne das Schlüsselwort JOIN.

Eigentlich steckt da ein verstecktes JOIN drin. In etwa so sieht das dann aus:

UPDATE students
SET debt = p.due_amount
FROM payments p
    JOIN students s ON s.id = p.student_id
WHERE students.id = p.student_id;

Wie siehst du, was genau aktualisiert wird?

Bevor du UPDATE abfeuerst, ist es super sinnvoll zu checken, was genau geändert wird. Das geht mit einem SELECT, der nach dem gleichen Prinzip aufgebaut ist:

SELECT
    students.id, 
    students.name, 
    students.debt AS alter_schuldenstand, 
    payments.due_amount AS neuer_schuldenstand
FROM students
    JOIN payments ON students.id = payments.student_id;

Das Ergebnis zeigt dir:

• den alten Wert der Schulden (alter_schuldenstand);
• den neuen Wert, der aus der Tabelle payments kommt (neuer_schuldenstand).

So kannst du deine Logik checken, bevor du die Daten endgültig überschreibst.

Typische Stolperfallen

• Wenn payments mehrere Einträge für einen Studenten enthält, gibt UPDATE einen Fehler: more than one row returned. Dann musst du entweder Aggregatfunktionen (MAX, SUM, LIMIT 1) nutzen oder sicherstellen, dass student_id in payments eindeutig ist.
• Denk dran: UPDATE ... FROM ist eine PostgreSQL-Spezialität und funktioniert so nicht in allen anderen Datenbanksystemen (z.B. MySQL).

Praktische Beispiele

Beispiel 1: Status von Studenten ändern

Stell dir vor, Studenten, die den Kurs abgeschlossen haben, bekommen den Status "absolvent". Wir haben die Spalte status. Um den Status für alle Studenten mit completed_course = true zu aktualisieren:

UPDATE students
SET status = 'absolvent'
WHERE completed_course = true;

Beispiel 2: Gehaltserhöhung für Mitarbeitende

Wenn du eine Tabelle employees hast und das Gehalt aller, die im Sales arbeiten, um 10% erhöhen willst:

UPDATE employees
SET salary = salary * 1.10
WHERE department = 'Sales';

Hier nutzen wir eine mathematische Operation direkt im SET-Teil. Das ist praktisch für Massenänderungen.

Beispiel 3: Bedingtes Update

Manchmal willst du Daten je nach Bedingung aktualisieren. Zum Beispiel: Wenn das Gehalt eines Mitarbeiters unter 50.000 liegt, soll es um 20% steigen, sonst um 10%:

UPDATE employees
SET salary = CASE
                WHEN salary < 50000 THEN salary * 1.20
                ELSE salary * 1.10
             END;

Hier kommt die CASE-Konstruktion zum Einsatz, um je nach Wert von salary unterschiedliche Regeln anzuwenden.

Typische Fehler beim UPDATE

Du hast es bestimmt schon erraten: Der häufigste Fehler ist das Vergessen von WHERE. Stell dir vor: Du hast eine Datenbank mit 10.000 Mitarbeitenden und erhöhst aus Versehen das Gehalt für alle. Auch wenn das deine Kollegen freut, für deine Karriere ist das eher… suboptimal.

Ein anderer häufiger Fehler: Die falsche Spalte aktualisieren. Check immer nochmal, was du wo reinschreibst. Ein einfacher SELECT vor dem UPDATE kann dir echt viel Ärger ersparen.