So erstellen Sie einen Primärschlüssel in SQL Server (T-SQL-Beispiele)

Dieser Artikel zeigt, wie Sie einen Primärschlüssel in SQL Server erstellen, wenn Sie eine Tabelle mit Transact-SQL erstellen.

Ein Primärschlüssel ist eine oder mehrere Spalten, die als eindeutige Kennung für eine bestimmte Tabelle konfiguriert wurden. Primärschlüssel können verwendet werden, um die Datenintegrität in der Tabelle zu erzwingen.

Eine Tabelle kann nur einen Primärschlüssel haben und Primärschlüssel können nur zu Spalten hinzugefügt werden, die als NOT NULL definiert sind .

Dieser Artikel zeigt, wie Sie einen Primärschlüssel in einem neuen erstellen Tabelle (d. h. beim Erstellen der Tabelle). Wenn Sie einen Primärschlüssel in einem vorhandenen erstellen müssen Tabelle finden Sie unter Hinzufügen eines Primärschlüssels zu einer vorhandenen Tabelle in SQL Server.

Beispiel 1 – Erstellen Sie eine Tabelle mit einem Primärschlüssel

Zuerst erstelle ich eine Testdatenbank:

CREATE DATABASE PK_Test;

Erstellen Sie nun eine neue Tabelle, die eine Primärschlüssel-Einschränkung enthält:

USE PK_Test;

CREATE TABLE Colors
(
    ColorId int IDENTITY (1,1) NOT NULL PRIMARY KEY,
    ColorName varchar(50)
);

Dadurch wurde eine neue Tabelle mit dem Namen Colors erstellt die eine Primärschlüsseleinschränkung für ihre ColorId hat Säule.

Beispiel 2 – Überprüfung der Primärschlüsselbeschränkung

Wir können 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__Colors__8DA7674DD34F4585 | PK     | 1                 | 1                 |
+------------------------------+--------+-------------------+-------------------+

Ich habe die Spalten für dieses Beispiel eingegrenzt. Die sys.key_constraints Die Systemansicht gibt mehr Spalten als diese zurück. Sie können immer den * verwenden Platzhalter, um auf Wunsch alle Spalten zurückzugeben.

Wir können anhand des Abfrageergebnisses sehen, dass diese Datenbank nur einen Primärschlüssel hat (den wir gerade erstellt haben).

In diesem Fall wurde der Primärschlüssel automatisch vom System benannt. Sie haben auch die Möglichkeit, Ihren eigenen Namen anzugeben (dazu später mehr).

Beispiel 3 – Überprüfen Sie den Index

Standardmäßig wird ein gruppierter Index erstellt, wenn Sie den Primärschlüssel erstellen. Sie können den Clustered-Index explizit angeben oder automatisch erstellen lassen. Sie haben auch die Möglichkeit, einen Nonclustered-Index anzugeben.

Hier ist eine Abfrage, die den Index zurückgibt, der automatisch erstellt wurde, als ich den obigen Primärschlüssel erstellt habe:

SELECT *
FROM sys.indexes
WHERE name = 'PK__Colors__8DA7674DD34F4585';

Ergebnis (bei vertikaler Ausgabe):

object_id                  | 885578193
name                       | PK__Colors__8DA7674DD34F4585
index_id                   | 1
type                       | 1
type_desc                  | CLUSTERED
is_unique                  | 1
data_space_id              | 1
ignore_dup_key             | 0
is_primary_key             | 1
is_unique_constraint       | 0
fill_factor                | 0
is_padded                  | 0
is_disabled                | 0
is_hypothetical            | 0
is_ignored_in_optimization | 0
allow_row_locks            | 1
allow_page_locks           | 1
has_filter                 | 0
filter_definition          | NULL
compression_delay          | NULL
suppress_dup_key_messages  | 0
auto_created               | 0

In diesem Fall habe ich die Ergebnisse auf die Zeile eingegrenzt, die denselben Namen wie der gerade erstellte Primärschlüssel enthält. Sie können das WHERE jederzeit entfernen -Klausel, wenn Sie mehr Ergebnisse zurückgeben möchten.

Wir können sehen, dass dieser Index einen type_desc hat von CLUSTERED .

Beispiel 4 – Benennen des Primärschlüssels

Der Primärschlüssel, den wir oben erstellt haben, wurde automatisch vom System benannt. Sie können Ihren eigenen Namen angeben, wenn Sie dies bevorzugen.

Hier ist ein Beispiel für die Angabe eines Namens für den Primärschlüssel. In diesem Fall gebe ich auch einen Nonclustered-Index an.

USE PK_Test;

CREATE TABLE Cats
(
    CatId int IDENTITY (1,1) NOT NULL, 
       CONSTRAINT PK_Cats_CatId PRIMARY KEY NONCLUSTERED (CatId),
    CatName varchar(50)
);

In diesem Fall verwende ich den optionalen CONSTRAINT Schlüsselwort, um den Beginn der Definition des Primärschlüssels anzuzeigen, gefolgt von meinem gewählten Namen für den Primärschlüssel. Ich verwende auch den NONCLUSTERED Schlüsselwort, um anzugeben, dass es sich um einen ungeclusterten Index handelt.

Überprüfen Sie den Primärschlüssel:

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__Colors__8DA7674DD34F4585 | PK     | 1                 | 1                 |
| PK_Cats_CatId                | PK     | 2                 | 0                 |
+------------------------------+--------+-------------------+-------------------+

Prüfen Sie den Index:

SELECT *
FROM sys.indexes
WHERE name = 'PK_Cats_CatId';

Ergebnis (bei vertikaler Ausgabe):

object_id                  | 917578307
name                       | PK_Cats_CatId
index_id                   | 2
type                       | 2
type_desc                  | NONCLUSTERED
is_unique                  | 1
data_space_id              | 1
ignore_dup_key             | 0
is_primary_key             | 1
is_unique_constraint       | 0
fill_factor                | 0
is_padded                  | 0
is_disabled                | 0
is_hypothetical            | 0
is_ignored_in_optimization | 0
allow_row_locks            | 1
allow_page_locks           | 1
has_filter                 | 0
filter_definition          | NULL
compression_delay          | NULL
suppress_dup_key_messages  | 0
auto_created               | 0

Wir können also sehen, dass diesmal der type_desc ist NONCLUSTERED .

Beachten Sie, dass beim Erstellen einer Tabelle CLUSTERED kann nur für eine Einschränkung angegeben werden. Wenn es für einen UNIQUE angegeben ist Einschränkung und einen PRIMARY KEY Bedingung wird auch angegeben, der PRIMARY KEY ist standardmäßig NONCLUSTERED .

Beispiel 5 – Erstellen Sie einen Primärschlüssel für eine Nullable-Spalte

Ein Primärschlüssel kann nur für Spalten erstellt werden, die als NOT NULL definiert sind . Wenn Sie versuchen, einen Primärschlüssel für eine Spalte zu erstellen, die auf NULL gesetzt ist , erhalten Sie eine Fehlermeldung.

Wenn Sie die Nullfähigkeit jedoch nicht angeben, wird die Spalte auf NOT NULL gesetzt standardmäßig.

Um dies zu demonstrieren, erstellen wir eine weitere Tabelle, aber dieses Mal setzen wir sie auf NULL :

USE PK_Test;

CREATE TABLE Dogs
(
    DogId int IDENTITY (1,1) NULL PRIMARY KEY,
    DogName varchar(50)
);

Ergebnis:

Msg 8147, Level 16, State 1, Line 3
Could not create IDENTITY attribute on nullable column 'DogId', table 'Dogs'.
Msg 8111, Level 16, State 1, Line 3
Cannot define PRIMARY KEY constraint on nullable column in table 'Dogs'.
Msg 1750, Level 16, State 0, Line 3
Could not create constraint or index. See previous errors.

Wie erwartet erhalten wir einen Fehler.

Lassen Sie uns NULL entfernen aus der Tabellendefinition und versuchen Sie es erneut:

USE PK_Test;

CREATE TABLE Dogs
(
    DogId int IDENTITY (1,1) PRIMARY KEY,
    DogName varchar(50)
);

Ergebnis:

Commands completed successfully.
Total execution time: 00:00:00.015

Diesmal wurde die Tabelle erfolgreich erstellt.

Werfen wir einen Blick darauf:

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 = 'DogId';

Ergebnis:

+---------+----------+---------------+---------------+
| Table   | Column   | is_nullable   | is_identity   |
|---------+----------+---------------+---------------|
| Dogs    | DogId    | 0             | 1             |
+---------+----------+---------------+---------------+

Wir können also sehen, dass es nicht nullable ist, weil is_nullable Flag ist auf 0 gesetzt .

Beispiel 6 – Primärschlüssel auf mehreren Spalten

Sie können auch einen Primärschlüssel für mehrere Spalten erstellen. Mehrspaltige Primärschlüssel werden auch als zusammengesetzte Primärschlüssel bezeichnet. Um einen zusammengesetzten Primärschlüssel zu erstellen, trennen Sie die Spalten bei der Definition des Schlüssels einfach durch ein Komma.

So:

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

Hier ist ein Beispiel für eine Situation, in der ein mehrspaltiger Primärschlüssel verwendet werden könnte:

CREATE TABLE Musician (
MusicianId int NOT NULL,
FirstName varchar(60),
LastName varchar(60),
CONSTRAINT PK_Musician PRIMARY KEY (MusicianID)
);

CREATE TABLE Band (
BandId int NOT NULL,
BandName varchar(255),
CONSTRAINT PK_Band PRIMARY KEY (BandId)
);

CREATE TABLE BandMember (
MusicianId int NOT NULL,
BandId int NOT NULL,
CONSTRAINT PK_BandMember PRIMARY KEY (MusicianID, BandId),
CONSTRAINT FK_BandMember_Band FOREIGN KEY (BandId) REFERENCES Band(BandId),
CONSTRAINT FK_BandMember_Musician FOREIGN KEY (MusicianId) REFERENCES Musician(MusicianId)
);

In diesem Beispiel das BandMember Tabelle hat einen mehrspaltigen Primärschlüssel. In diesem Fall ist jede Spalte im Primärschlüssel auch ein Fremdschlüssel zum Primärschlüssel einer anderen Tabelle, aber das ist keine Voraussetzung.

Eine ausführlichere Erläuterung dieses Beispiels finden Sie unter So erstellen Sie einen zusammengesetzten Primärschlüssel in SQL Server.

Siehe auch So erstellen Sie einen zusammengesetzten Fremdschlüssel in SQL Server für ein Beispiel, das mit einem mehrspaltigen Fremdschlüssel, der auf den obigen zusammengesetzten Primärschlüssel verweist, noch einen Schritt weiter geht.