Jak utworzyć klucz podstawowy w SQL Server (przykłady T-SQL)

W tym artykule pokazano, jak utworzyć klucz podstawowy w programie SQL Server podczas tworzenia tabeli przy użyciu języka Transact-SQL.

Klucz podstawowy to co najmniej jedna kolumna, która została skonfigurowana jako unikalny identyfikator dla danej tabeli. Klucze podstawowe mogą być użyte do wymuszenia integralności danych w tabeli.

Tabela może mieć tylko jeden klucz podstawowy, a klucze podstawowe można dodawać tylko do kolumn, które są zdefiniowane jako NOT NULL .

Ten artykuł pokazuje, jak utworzyć klucz podstawowy w nowym tabela (tj. podczas tworzenia tabeli). Jeśli musisz utworzyć klucz podstawowy w istniejącym tabeli, zobacz Jak dodać klucz główny do istniejącej tabeli w SQL Server.

Przykład 1 – Utwórz tabelę z kluczem podstawowym

Najpierw stworzę testową bazę danych:

CREATE DATABASE PK_Test;

Teraz utwórz nową tabelę zawierającą ograniczenie klucza podstawowego:

USE PK_Test;

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

Spowodowało to utworzenie nowej tabeli o nazwie Colors który ma ograniczenie klucza podstawowego na swoim ColorId kolumna.

Przykład 2 – Sprawdź ograniczenie klucza podstawowego

Możemy uruchomić następujący kod, aby zwrócić listę ograniczeń klucza głównego w bazie danych:

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

Wynik:

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

W tym przykładzie zawęziłem kolumny. sys.key_constraints widok systemowy zwraca więcej kolumn niż to. Zawsze możesz użyć * symbol wieloznaczny, aby zwrócić wszystkie kolumny, jeśli chcesz.

Na podstawie wyniku zapytania widzimy, że ta baza danych ma tylko jeden klucz podstawowy (ten, który właśnie utworzyliśmy).

W tym przypadku klucz podstawowy został automatycznie nazwany przez system. Masz również możliwość podania własnego imienia (więcej o tym później).

Przykład 3 – Sprawdź indeks

Domyślnie indeks klastrowy jest tworzony podczas tworzenia klucza podstawowego. Indeks klastrowy można określić jawnie lub zezwolić na jego utworzenie automatycznie. Masz również możliwość określenia indeksu nieklastrowanego.

Oto zapytanie, które zwraca indeks, który został utworzony automatycznie podczas tworzenia powyższego klucza podstawowego:

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

Wynik (przy użyciu wyjścia pionowego):

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

W tym przypadku zawęziłem wyniki tylko do wiersza zawierającego tę samą nazwę klucza podstawowego, który właśnie utworzyłem. Zawsze możesz usunąć WHERE klauzula, jeśli potrzebujesz więcej wyników do zwrócenia.

Widzimy, że ten indeks ma type_desc z KLASTRA .

Przykład 4 – Nazywanie klucza podstawowego

Klucz podstawowy, który utworzyliśmy powyżej, został automatycznie nazwany przez system. Jeśli wolisz, możesz podać własne imię.

Oto przykład określenia nazwy klucza podstawowego. W tym przypadku określam również indeks nieklastrowany.

USE PK_Test;

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

W tym przypadku używam opcjonalnego CONSTRAINT słowo kluczowe, aby wskazać początek definicji klucza podstawowego, po którym następuje moja wybrana nazwa klucza podstawowego. Używam również NONCLUSTERED słowo kluczowe, aby określić, że indeks nieklastrowany.

Sprawdź klucz główny:

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

Wynik:

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

Sprawdź indeks:

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

Wynik (przy użyciu wyjścia pionowego):

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

Widzimy więc, że tym razem type_desc jest NIEZKLEJONY .

Zwróć uwagę, że podczas tworzenia tabeli CLUSTERED można określić tylko dla jednego ograniczenia. Jeśli jest określony dla UNIQUE ograniczenie i PRIMARY KEY określono również ograniczenie, PRIMARY KEY domyślnie NONCLUSTERED .

Przykład 5 – Utwórz klucz podstawowy w kolumnie z wartością null

Klucz podstawowy można utworzyć tylko dla kolumn, które są zdefiniowane jako NOT NULL . Jeśli spróbujesz utworzyć klucz podstawowy w kolumnie, która jest ustawiona na NULL , pojawi się błąd.

Jeśli jednak nie określisz dopuszczalności wartości null, kolumna zostanie ustawiona na NOT NULL domyślnie.

Aby to zademonstrować, stwórzmy kolejną tabelę, ale tym razem ustawimy ją na NULL :

USE PK_Test;

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

Wynik:

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.

Zgodnie z oczekiwaniami otrzymujemy błąd.

Usuńmy NULL z definicji tabeli i spróbuj ponownie:

USE PK_Test;

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

Wynik:

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

Tym razem stół został pomyślnie utworzony.

Rzućmy okiem na to:

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

Wynik:

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

Widzimy więc, że nie ma wartości null, ponieważ jest_nullable flaga jest ustawiona na 0 .

Przykład 6 – klucz podstawowy w wielu kolumnach

Możesz także utworzyć klucz podstawowy w wielu kolumnach. Wielokolumnowe klucze podstawowe są również znane jako złożone klucze podstawowe. Aby utworzyć złożony klucz podstawowy, po prostu oddziel kolumny przecinkiem podczas definiowania klucza.

Tak:

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

Oto przykład sytuacji, w której można użyć wielokolumnowego klucza podstawowego:

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

W tym przykładzie BandMember tabela ma wielokolumnowy klucz podstawowy. W tym przypadku każda kolumna w kluczu podstawowym jest również kluczem obcym do klucza podstawowego innej tabeli, ale nie jest to wymagane.

Zobacz Jak utworzyć złożony klucz podstawowy w SQL Server, aby uzyskać bardziej szczegółowe wyjaśnienie tego przykładu.

Zobacz także Jak utworzyć złożony klucz obcy w SQL Server, aby zapoznać się z przykładem, który idzie o krok dalej z wielokolumnowym kluczem obcym, który odwołuje się do powyższego złożonego klucza podstawowego.