SQL ALTER TABLE Add Column: Der komplette Leitfaden

Einer bestehenden Tabelle in SQL eine Spalte hinzuzufügen, ist eine häufige Aufgabe, wenn sich dein Datenbankschema weiterentwickelt. Mit der Anweisung ALTER TABLE kannst du die Struktur einer bestehenden Tabelle ändern, ohne Daten zu verlieren. Dieser Leitfaden zeigt dir anhand praktischer Beispiele, wie du mit ALTER TABLE Spalten hinzufügst.

ALTER TABLE verstehen

Mit dem Befehl ALTER TABLE kannst du Spalten in einer bestehenden Tabelle hinzufügen, löschen oder ändern. Außerdem lassen sich damit Tabellen-Constraints ändern. Dieses Tutorial konzentriert sich speziell auf das Hinzufügen neuer Spalten.

Wenn du eine neue Spalte hinzufügst, musst du den Spaltennamen, den Datentyp sowie eventuelle zusätzliche Constraints oder Standardwerte angeben. Die Operation ist atomar und wirkt sich nicht auf bestehende Daten aus.

Grundlegende Syntax zum Hinzufügen einer Spalte

So sieht die grundlegende Syntax aus, um einer Tabelle eine neue Spalte hinzuzufügen:

ALTER TABLE table_name
ADD column_name column_type [constraint];

• table_name: Der Name der Tabelle, der du eine Spalte hinzufügst.
• column_name: Der Name der neuen Spalte.
• column_type: Der Datentyp der neuen Spalte (z. B. VARCHAR, INT, DATE usw.).
• constraint: Optional. Zusätzliche Constraints wie NOT NULL, UNIQUE oder DEFAULT-Werte.

Beispiel: Eine Spalte hinzufügen

Fangen wir mit einer einfachen Tabelle employees an:

CREATE TABLE employees (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    position VARCHAR(50)
);

-- Current data in employees table:
INSERT INTO employees (id, name, position) VALUES (1, 'Alice', 'Engineer');
INSERT INTO employees (id, name, position) VALUES (2, 'Bob', 'Manager');

SELECT * FROM employees;

Ausgabe:

+----+-------+----------+
| id | name  | position |
+----+-------+----------+
|  1 | Alice | Engineer |
|  2 | Bob   | Manager  |
+----+-------+----------+

Eine neue Spalte für das Gehalt hinzufügen

Fügen wir eine neue Spalte namens salary mit dem Datentyp DECIMAL(10, 2) hinzu, die Zahlen mit bis zu 10 Stellen speichern kann, davon 2 Nachkommastellen:

ALTER TABLE employees
ADD salary DECIMAL(10, 2);

Dieser Befehl ergänzt die Tabelle employees um die neue Spalte salary. Bestehende Zeilen haben in dieser Spalte NULL-Werte, bis du sie aktualisierst.

Die Tabellenstruktur überprüfen

Prüfe mit DESCRIBE oder SHOW COLUMNS (je nach Datenbanksystem), ob die Spalte hinzugefügt wurde:

DESCRIBE employees;

Ausgabe:

+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| id       | int         | NO   | PRI | NULL    |       |
| name     | varchar(100)| YES  |     | NULL    |       |
| position | varchar(50) | YES  |     | NULL    |       |
| salary   | decimal(10,2)| YES |     | NULL    |       |
+----------+-------------+------+-----+---------+-------+

Eine Spalte mit Standardwert hinzufügen

Du kannst eine Spalte auch mit einem Standardwert hinzufügen. So fügst du eine Spalte hire_date hinzu, die standardmäßig das aktuelle Datum enthält:

ALTER TABLE employees
ADD hire_date DATE DEFAULT CURRENT_DATE;

Bei neuen Zeilen in der Tabelle employees wird hire_date automatisch auf das aktuelle Datum gesetzt, wenn kein Wert angegeben ist.

Eine Spalte mit NOT NULL-Constraint hinzufügen

Eine Spalte mit NOT NULL-Constraint zu einer bestehenden Tabelle hinzuzufügen, erfordert besondere Sorgfalt. Du kannst einer Tabelle, die bereits Daten enthält, nicht einfach eine NOT NULL-Spalte ohne Standardwert hinzufügen, da dies den Constraint für bestehende Zeilen verletzen würde.

Das Problem mit NOT NULL bei bestehenden Daten

Dieser Befehl schlägt fehl, wenn die Tabelle bereits Zeilen enthält:

-- This will fail on tables with existing data
ALTER TABLE employees
ADD phone_number VARCHAR(20) NOT NULL;

Der Fehler tritt auf, weil bestehende Zeilen in der neuen Spalte NULL-Werte hätten und damit den NOT NULL-Constraint verletzen würden.

Lösung 1: Spalte mit Standardwert hinzufügen

Die einfachste Lösung ist, einen Standardwert anzugeben:

ALTER TABLE employees
ADD phone_number VARCHAR(20) NOT NULL DEFAULT 'Unknown';

Das funktioniert, weil:

1. die Spalte für alle bestehenden Zeilen mit dem Standardwert hinzugefügt wird
2. der NOT NULL-Constraint sofort erfüllt ist
3. künftige Inserts einen Wert angeben oder den Standardwert verwenden müssen

Lösung 2: Mehrstufiges Vorgehen

Für mehr Kontrolle über die Werte nutzt du ein mehrstufiges Vorgehen:

-- Step 1: Add the column as nullable
ALTER TABLE employees
ADD phone_number VARCHAR(20);

-- Step 2: Update existing rows with appropriate values
UPDATE employees 
SET phone_number = 'Unknown' 
WHERE phone_number IS NULL;

-- Step 3: Add the NOT NULL constraint
ALTER TABLE employees
ALTER COLUMN phone_number SET NOT NULL;

Hinweis: Die Syntax für Schritt 3 unterscheidet sich je nach Datenbanksystem:

• PostgreSQL: ALTER COLUMN phone_number SET NOT NULL
• MySQL: MODIFY COLUMN phone_number VARCHAR(20) NOT NULL
• SQL Server: ALTER COLUMN phone_number VARCHAR(20) NOT NULL

Lösung 3: Bedingte Standardwerte

Du kannst je nach bestehenden Daten unterschiedliche Standardwerte setzen:

-- Add column with temporary default
ALTER TABLE employees
ADD department VARCHAR(50) NOT NULL DEFAULT 'TBD';

-- Update with conditional logic based on position
UPDATE employees 
SET department = CASE 
    WHEN position = 'Engineer' THEN 'Engineering'
    WHEN position = 'Manager' THEN 'Management'
    ELSE 'General'
END;

-- Optionally remove the default if you don't want it for future inserts
ALTER TABLE employees
ALTER COLUMN department DROP DEFAULT;

Best Practices für NOT NULL-Spalten

1. Vorausplanen: Berücksichtige NOT NULL-Constraints schon beim ersten Tabellendesign
2. Sinnvolle Standardwerte nutzen: Wähle Standardwerte, die zu deiner Geschäftslogik passen
3. Erst testen: Teste ALTER TABLE-Operationen immer an einer Kopie deiner Daten
4. Änderungen dokumentieren: Halte Schemaänderungen fest, damit dein Team Bescheid weiß
5. Datenmigration bedenken: Plane, wie du die neue Spalte mit sinnvollen Daten füllst

NOT NULL-Constraints überprüfen

Nachdem du eine NOT NULL-Spalte hinzugefügt hast, prüfe, ob der Constraint greift:

-- Check table structure
DESCRIBE employees;

-- Verify constraint by attempting to insert NULL (should fail)
INSERT INTO employees (id, name, position, phone_number) 
VALUES (3, 'Carol', 'Analyst', NULL);
-- Error: Column 'phone_number' cannot be null

Verwandte Operationen

Jetzt, wo du weißt, wie man Spalten hinzufügt, interessieren dich vielleicht auch andere ALTER TABLE-Operationen:

• Spalten mit ALTER TABLE umbenennen
• PostgreSQL: Spaltentyp ändern
• Spalten in Teradata hinzufügen

Diese Operationen sind unverzichtbar, um dein Datenbankschema zu pflegen und weiterzuentwickeln, wenn sich die Anforderungen deiner Anwendung ändern.

Fazit

Mit ALTER TABLE kannst du Spalten hinzufügen und dein Schema ohne Datenverlust ändern. Diese Flexibilität hilft dir, deine Datenbank an wachsende Anforderungen deiner Anwendung anzupassen. Erstelle vor Schemaänderungen immer ein Backup deiner Daten und prüfe die Kompatibilität mit der bestehenden Anwendungslogik.

Für fortgeschrittene Datenbankoperationen und eine effektive Verwaltung deiner SQL-Datenbanken lohnt sich ein Blick auf Beekeeper Studio – mit einer intuitiven Oberfläche für Schemaverwaltung und SQL-Operationen.