In diesem Artikel wird veranschaulicht, wie Sie mithilfe von Transact-SQL einen Primärschlüssel zu einer vorhandenen Tabelle in SQL Server hinzufügen.
Ein Primärschlüssel ist eine Spalte, die als eindeutige Kennung für eine bestimmte Tabelle konfiguriert wurde.
Normalerweise würden Sie beim Erstellen der Tabelle eine Primärschlüsseleinschränkung erstellen, aber Sie können auch einer vorhandenen Tabelle einen Primärschlüssel hinzufügen.
Beachten Sie, dass eine Tabelle nur einen Primärschlüssel haben kann. Sie können also keinen Primärschlüssel hinzufügen, wenn die Tabelle bereits einen hat.
Außerdem können Primärschlüssel nur zu Spalten hinzugefügt werden, die als NOT NULL definiert sind .
Beispiel 1 – Fügen Sie eine Primärschlüsselbeschränkung hinzu
In diesem Beispiel erstelle ich eine Tabelle, aber ich vergesse, eine Primärschlüsseleinschränkung hinzuzufügen. Also gehe ich zurück und ändere die Tabelle so, dass sie einen Primärschlüssel hat.
Erstellen Sie die Tabelle (aber vergessen Sie, einen Primärschlüssel zu erstellen ):
USE Test;
CREATE TABLE Colors
(
ColorId int IDENTITY (1,1) NOT NULL,
ColorName varchar(50)
);
Ergebnis:
Commands completed successfully. Total execution time: 00:00:00.058
Hoppla – ich habe vergessen, den Primärschlüssel zu erstellen!
Kein Problem! Wir können jetzt einen hinzufügen:
ALTER TABLE Colors ADD CONSTRAINT PK_Colors_ColorId PRIMARY KEY CLUSTERED (ColorId);
Ergebnis:
Commands completed successfully. Total execution time: 00:00:00.031
Dies hat nun einen PRIMARY KEY hinzugefügt Einschränkung für die ColorId Säule.
Beispiel 2 – Überprüfung der Primärschlüsselbeschränkung
Lassen Sie uns den folgenden Code ausführen, um eine Liste der Primärschlüsseleinschränkungen in der Datenbank zurückzugeben:
SELECT name, type, unique_index_id, is_system_named FROM sys.key_constraints WHERE type = 'PK';
Ergebnis:
+------------------------------+--------+-------------------+-------------------+ | name | type | unique_index_id | is_system_named | |------------------------------+--------+-------------------+-------------------| | PK__MyTest__606C418F16F9CCCF | PK | 1 | 1 | | PK__Client__96ADCE1ACB91C2A9 | PK | 1 | 1 | | PK_Colors_ColorId | PK | 1 | 0 | +------------------------------+--------+-------------------+-------------------+
Ihre Ergebnisse werden je nach den Primärschlüsseln in Ihrer Datenbank unterschiedlich sein.
Beachten Sie auch, dass diese Systemansicht mehr Spalten zurückgibt, als ich hier angegeben habe, aber Sie können den * verwenden Platzhalter, um auf Wunsch alle Spalten zurückzugeben.
Beispiel 3 – Hinzufügen eines Primärschlüssels zu einer Spalte, die NULL-Werte zulässt
Ein Primärschlüssel kann nur Spalten hinzugefügt werden, die als NOT NULL definiert sind . Wenn Sie versuchen, einen Primärschlüssel zu einer Spalte hinzuzufügen, die nullfähig ist, erhalten Sie eine Fehlermeldung.
Um dies zu demonstrieren, erstellen wir eine weitere Tabelle, aber diesmal vergessen wir auch, die Spalte als NOT NULL anzugeben :
USE Test;
CREATE TABLE Colors2
(
ColorId int,
ColorName varchar(50)
);
Wir können die folgende Abfrage ausführen, um zu prüfen, ob die Spalte Nullen zulässt oder nicht:
SELECT t.name AS 'Table', c.name AS 'Column', c.is_nullable, c.is_identity FROM sys.columns c INNER JOIN sys.tables T ON c.object_id = t.object_id WHERE c.name = 'ColorId';
Ergebnis:
+---------+----------+---------------+---------------+ | Table | Column | is_nullable | is_identity | |---------+----------+---------------+---------------| | Colors | ColorId | 0 | 1 | | Colors2 | ColorId | 1 | 0 | +---------+----------+---------------+---------------+
Wir können sehen, dass die, die wir zuvor erstellt haben (in der Datei Colors table) ist nullable und ist eine Identitätsspalte. Die zweite (in der Colors2 table) ist nullable und ist keine Identitätsspalte.
Versuchen wir nun, der Nullable-Spalte eine Primärschlüssel-Einschränkung hinzuzufügen:
ALTER TABLE Colors2 ADD CONSTRAINT PK_Colors2_ColorId PRIMARY KEY CLUSTERED (ColorId);
Ergebnis:
Msg 8111, Level 16, State 1, Line 1 Cannot define PRIMARY KEY constraint on nullable column in table 'Colors2'. Msg 1750, Level 16, State 0, Line 1 Could not create constraint or index. See previous errors.
In diesem Fall müssen wir also die Spalte so ändern, dass sie NOT NULL ist bevor wir versuchen, ihn als Primärschlüssel zu definieren.
Wir können ALTER COLUMN verwenden innerhalb einer ALTER TABLE -Anweisung, um diese Spalte auf NOT NULL zu setzen :
ALTER TABLE Colors2 ALTER COLUMN ColorId int NOT NULL;
Sehen wir uns die Spalte noch einmal an:
SELECT t.name AS 'Table', c.name AS 'Column', c.is_nullable, c.is_identity FROM sys.columns c INNER JOIN sys.tables T ON c.object_id = t.object_id WHERE c.name = 'ColorId';
Ergebnis:
+---------+----------+---------------+---------------+ | Table | Column | is_nullable | is_identity | |---------+----------+---------------+---------------| | Colors | ColorId | 0 | 1 | | Colors2 | ColorId | 0 | 0 | +---------+----------+---------------+---------------+
Also können wir diese Colors2 sehen ist jetzt auf 0 gesetzt , was bedeutet, dass es nicht nullable ist (es kann keine NULL-Werte enthalten).
Beachten Sie auch, dass die Spalte nicht ist eine Identitätsspalte. Ich werde das später besprechen.
Wie auch immer, jetzt, wo die Spalte als NOT NULL definiert ist Wir können fortfahren und den Primärschlüssel hinzufügen:
ALTER TABLE Colors2 ADD CONSTRAINT PK_Colors2_ColorId PRIMARY KEY CLUSTERED (ColorId);
Ergebnis:
Commands completed successfully. Total execution time: 00:00:00.048
Lassen Sie uns zur Überprüfung noch einmal alle Primärschlüsseleinschränkungen für diese Tabelle überprüfen:
SELECT name, type, unique_index_id, is_system_named FROM sys.key_constraints WHERE type = 'PK';
Ergebnis:
+------------------------------+--------+-------------------+-------------------+ | name | type | unique_index_id | is_system_named | |------------------------------+--------+-------------------+-------------------| | PK__MyTest__606C418F16F9CCCF | PK | 1 | 1 | | PK__Client__96ADCE1ACB91C2A9 | PK | 1 | 1 | | PK_Colors_ColorId | PK | 1 | 0 | | PK_Colors2_ColorId | PK | 1 | 0 | +------------------------------+--------+-------------------+-------------------+
Unser neuer Primärschlüssel, den wir PK_Colors2_ColorId genannt haben wurde der Liste hinzugefügt.
Beispiel 4 – Ändern einer Spalte in eine Identitätsspalte
Primärschlüssel werden häufig auf Identitätsspalten angewendet. Identitätsspalten werden als solche mit dem IDENTITY definiert Schlüsselwort, gefolgt von einem optionalen Anfangs- und Inkrementwert in Klammern.
Wenn der Tabelle eine neue Zeile hinzugefügt wird, stellt SQL Server einen eindeutigen, inkrementellen Wert für die Identitätsspalte bereit.
Wenn Sie eine Identitätsspalte verwenden möchten, müssen Sie dies bereits getan haben. Sie können eine vorhandene Spalte nicht in eine Identitätsspalte ändern.
Als ich die Abfrage früher ausgeführt habe, konnten wir sehen, dass die Colors2.ColorId Spalte ist nicht eine Identitätsspalte (wir wissen das, weil is_identity auf 0 gesetzt ist ). Das heißt, ich habe die PK_Colors2_ColorId erstellt Primärschlüssel für eine Nicht-Identitätsspalte.
Folgendes passiert, wenn wir versuchen, die Tabelle in eine Identitätsspalte zu ändern:
ALTER TABLE Colors2 ALTER COLUMN ColorId int IDENTITY (1,1) NOT NULL PRIMARY KEY;
Ergebnis:
Msg 156, Level 15, State 1, Line 3 Incorrect syntax near the keyword 'IDENTITY'.
Wie bereits erwähnt, müssen wir, um dies zu überwinden, die Säule fallen lassen und neu beginnen.
Wenn die Spalte bereits Daten enthält, müssen Sie zusätzliche Arbeit leisten. Das würde den Rahmen dieses Artikels sprengen, aber hier ist ein Beispiel dafür, wie die obige Spalte gelöscht und als Identitätsspalte neu erstellt wird:
USE Test;
DROP TABLE Colors2;
CREATE TABLE Colors2
(
ColorId int IDENTITY (1,1) NOT NULL PRIMARY KEY,
ColorName varchar(50)
);
Ergebnis:
Commands completed successfully. Total execution time: 00:00:00.049
Beachten Sie, dass ich dieses Mal keinen Namen für die Primärschlüsseleinschränkung angegeben habe. In diesem Fall erstellt das System einen Namen dafür.
Überprüfen Sie schnell die Spalte:
SELECT t.name AS 'Table', c.name AS 'Column', c.is_nullable, c.is_identity FROM sys.columns c INNER JOIN sys.tables T ON c.object_id = t.object_id WHERE c.name = 'ColorId';
Ergebnis:
+---------+----------+---------------+---------------+ | Table | Column | is_nullable | is_identity | |---------+----------+---------------+---------------| | Colors | ColorId | 0 | 1 | | Colors2 | ColorId | 0 | 1 | +---------+----------+---------------+---------------+
Ja, es ist jetzt eine Identitätsspalte.
Sehen wir uns noch einmal die Primärschlüssel für diese Tabelle an:
SELECT name, type, unique_index_id, is_system_named FROM sys.key_constraints WHERE type = 'PK';
Ergebnis:
+-------------------------------+--------+-------------------+-------------------+ | name | type | unique_index_id | is_system_named | |-------------------------------+--------+-------------------+-------------------| | PK__MyTest__606C418F16F9CCCF | PK | 1 | 1 | | PK__Client__96ADCE1ACB91C2A9 | PK | 1 | 1 | | PK_Colors_ColorId | PK | 1 | 0 | | PK__Colors2__8DA7674D8F57294D | PK | 1 | 1 | +-------------------------------+--------+-------------------+-------------------+
Wir haben jetzt also einen vom System benannten Primärschlüssel namens PK__Colors2__8DA7674D8F57294D .
