Hur man skapar en primär nyckel i SQL Server (T-SQL-exempel)

Den här artikeln visar hur du skapar en primärnyckel i SQL Server när du skapar en tabell med Transact-SQL.

En primärnyckel är en eller flera kolumner som har konfigurerats som den unika identifieraren för en given tabell. Primära nycklar kan användas för att framtvinga dataintegritet i tabellen.

En tabell kan bara ha en primärnyckel, och primärnycklar kan bara läggas till i kolumner som är definierade som NOT NULL .

Den här artikeln visar hur man skapar en primärnyckel i en ny tabell (dvs. när du skapar tabellen). Om du behöver skapa en primärnyckel i en befintlig tabell, se Hur man lägger till en primärnyckel till en befintlig tabell i SQL Server.

Exempel 1 – Skapa en tabell med en primärnyckel

Först skapar jag en testdatabas:

CREATE DATABASE PK_Test;

Skapa nu en ny tabell som innehåller en primärnyckelbegränsning:

USE PK_Test;

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

Detta skapade en ny tabell som heter Colors som har en primärnyckelrestriktion på sin ColorId kolumn.

Exempel 2 – Kontrollera den primära nyckelbegränsningen

Vi kan köra följande kod för att returnera en lista över primära nyckelbegränsningar i databasen:

SELECT
  name,
  type,
  unique_index_id,
  is_system_named
FROM sys.key_constraints
WHERE type = 'PK';

Resultat:

+------------------------------+--------+-------------------+-------------------+
| name                         | type   | unique_index_id   | is_system_named   |
|------------------------------+--------+-------------------+-------------------|
| PK__Colors__8DA7674DD34F4585 | PK     | 1                 | 1                 |
+------------------------------+--------+-------------------+-------------------+

Jag har minskat kolumnerna för det här exemplet. sys.key_constraints systemvyn returnerar fler kolumner än så här. Du kan alltid använda * jokertecken för att returnera alla kolumner om du vill.

Vi kan se av frågeresultatet att denna databas bara har en primärnyckel (den vi just skapade).

I det här fallet namngavs primärnyckeln automatiskt av systemet. Du har också möjlighet att ange ditt eget namn (mer om det senare).

Exempel 3 – Kontrollera indexet

Som standard skapas ett klustrat index när du skapar primärnyckeln. Du kan ange det klustrade indexet uttryckligen eller låta det skapas automatiskt. Du har också möjlighet att ange ett icke-klustrat index.

Här är en fråga som returnerar indexet som skapades automatiskt när jag skapade primärnyckeln ovan:

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

Resultat (med vertikal utdata):

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

I det här fallet har jag begränsat resultaten till bara raden som innehåller samma namn på primärnyckeln som jag just skapade. Du kan alltid ta bort WHERE klausul om du behöver fler resultat som ska returneras.

Vi kan se att detta index har en type_desc av CLUSTERED .

Exempel 4 – Namnge den primära nyckeln

Den primära nyckeln som vi skapade ovan namngavs automatiskt av systemet. Du kan ange ditt eget namn om du föredrar det.

Här är ett exempel på hur du anger ett namn för primärnyckeln. I det här fallet anger jag också ett icke-klustrat index.

USE PK_Test;

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

I det här fallet använder jag den valfria CONSTRAINT nyckelord för att indikera början av definitionen av primärnyckeln, följt av mitt valda namn för primärnyckeln. Jag använder också NONCLUSTERED nyckelord för att ange att ett icke-klustrat index.

Kontrollera primärnyckeln:

SELECT
  name,
  type,
  unique_index_id,
  is_system_named
FROM sys.key_constraints
WHERE type = 'PK';

Resultat:

+------------------------------+--------+-------------------+-------------------+
| name                         | type   | unique_index_id   | is_system_named   |
|------------------------------+--------+-------------------+-------------------|
| PK__Colors__8DA7674DD34F4585 | PK     | 1                 | 1                 |
| PK_Cats_CatId                | PK     | 2                 | 0                 |
+------------------------------+--------+-------------------+-------------------+

Kontrollera indexet:

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

Resultat (med vertikal utdata):

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

Så vi kan se att den här gången type_desc är ICLUSTERAD .

Observera att när du skapar en tabell, CLUSTERED kan endast anges för en begränsning. Om det är specificerat för en UNIQUE begränsning och en PRIMARY KEY begränsning är också specificerad, PRIMARY KEY standard till NONCLUSTERED .

Exempel 5 – Skapa en primärnyckel på en nullbar kolumn

En primärnyckel kan endast skapas för kolumner som är definierade som NOT NULL . Om du försöker skapa en primärnyckel på en kolumn som är inställd på NULL , får du ett felmeddelande.

Men om du inte anger nollbarheten är kolumnen satt till NOT NULL som standard.

För att demonstrera detta, låt oss skapa en annan tabell, men den här gången ställer vi in ​​den till NULL :

USE PK_Test;

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

Resultat:

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.

Som väntat får vi ett fel.

Låt oss ta bort NULL från tabelldefinitionen och försök igen:

USE PK_Test;

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

Resultat:

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

Den här gången skapades tabellen framgångsrikt.

Låt oss ta en titt på det:

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

Resultat:

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

Så vi kan se att det inte är nullbart, eftersom is_nullable flaggan är inställd på 0 .

Exempel 6 – Primär nyckel på flera kolumner

Du kan också skapa en primärnyckel på flera kolumner. Primärnycklar med flera kolumner är också kända som sammansatta primärnycklar. För att skapa en sammansatt primärnyckel, separera helt enkelt kolumnerna med ett kommatecken när du definierar nyckeln.

Så här:

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

Här är ett exempel på en situation där en primärnyckel med flera kolumner kan användas:

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)
);

I det här exemplet är BandMember tabellen har en primärnyckel med flera kolumner. I det här fallet är varje kolumn i primärnyckeln också en främmande nyckel till primärnyckeln i en annan tabell, men detta är inte ett krav.

Se Hur man skapar en sammansatt primärnyckel i SQL Server för en mer detaljerad förklaring av detta exempel.

Se även Hur man skapar en sammansatt främmande nyckel i SQL Server för ett exempel som tar det ett steg längre med en främmande nyckel med flera kolumner som refererar till ovanstående sammansatta primärnyckel.