Как да създадете първичен ключ в SQL Server (T-SQL примери)

Тази статия демонстрира как да създадете първичен ключ в SQL Server, когато създавате таблица с помощта на Transact-SQL.

Първичният ключ е една или повече колони, които са конфигурирани като уникален идентификатор за дадена таблица. Първичните ключове могат да се използват за налагане на целостта на данните в таблицата.

Таблицата може да има само един първичен ключ и първичните ключове могат да се добавят само към колони, които са дефинирани като NOT NULL .

Тази статия демонстрира как да създадете първичен ключ в нов таблица (т.е. при създаване на таблицата). Ако трябва да създадете първичен ключ в съществуващ таблица, вижте Как да добавите първичен ключ към съществуваща таблица в SQL Server.

Пример 1 – Създайте таблица с първичен ключ

Първо ще създам тестова база данни:

CREATE DATABASE PK_Test;

Сега създайте нова таблица, която включва ограничение за първичен ключ:

USE PK_Test;

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

Това създаде нова таблица, наречена Colors който има ограничение за първичен ключ за своя ColorId колона.

Пример 2 – Проверете ограничението на първичния ключ

Можем да изпълним следния код, за да върнем списък с ограничения на първичния ключ в базата данни:

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

Резултат:

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

Стесних колоните за този пример. sys.key_constraints системният изглед връща повече колони от това. Винаги можете да използвате * заместващ знак, за да върнете всички колони, ако желаете.

От резултата от заявката можем да видим, че тази база данни има само един първичен ключ (този, който току-що създадохме).

В този случай първичният ключ е автоматично именуван от системата. Освен това имате възможност да предоставите собствено име (повече за това по-късно).

Пример 3 – Проверете индекса

По подразбиране се създава клъстериран индекс, когато създавате първичен ключ. Можете да посочите клъстерирания индекс изрично или да го оставите да бъде създаден автоматично. Имате и опцията да посочите неклъстериран индекс.

Ето заявка, която връща индекса, който беше създаден автоматично, когато създадох горния първичен ключ:

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

Резултат (с помощта на вертикален изход):

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

В този случай стесних резултатите само до реда, който съдържа същото име на първичния ключ, който току-що създадох. Винаги можете да премахнете WHERE клауза, ако имате нужда от повече резултати, за да бъдат върнати.

Можем да видим, че този индекс има type_desc от КЛУСТРИРАНИ .

Пример 4 – Именуване на първичния ключ

Първичният ключ, който създадохме по-горе, беше автоматично именуван от системата. Можете да посочите собственото си име, ако предпочитате.

Ето пример за посочване на име за първичния ключ. В този случай посочвам и неклъстериран индекс.

USE PK_Test;

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

В този случай използвам незадължителното CONSTRAINT ключова дума, за да посочи началото на дефиницията на първичния ключ, последвана от избраното от мен име за първичен ключ. Аз също използвам NONCLUSTERED ключова дума, за да посочите, че е неклъстериран индекс.

Проверете първичния ключ:

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

Резултат:

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

Проверете индекса:

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

Резултат (с помощта на вертикален изход):

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

Така че можем да видим, че този път type_desc е НЕКЛУСТРИРАН .

Имайте предвид, че когато създавате таблица, CLUSTERED може да се посочи само за едно ограничение. Ако е посочено за UNIQUE ограничение и PRIMARY KEY ограничението също е посочено, PRIMARY KEY по подразбиране е NONCLUSTERED .

Пример 5 – Създаване на първичен ключ в колона с възможност за нула

Първичен ключ може да бъде създаден само за колони, които са дефинирани като NOT NULL . Ако се опитате да създадете първичен ключ в колона, която е настроена на NULL , ще получите грешка.

Ако обаче не посочите възможността за нула, колоната е зададена на NOT NULL по подразбиране.

За да демонстрираме това, нека създадем друга таблица, но този път ще я зададем на NULL :

USE PK_Test;

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

Резултат:

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.

Както се очакваше, получаваме грешка.

Нека премахнем NULL от дефиницията на таблицата и опитайте отново:

USE PK_Test;

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

Резултат:

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

Този път таблицата беше създадена успешно.

Нека да го разгледаме:

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

Резултат:

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

Така че можем да видим, че не е nullable, защото is_nullable флагът е настроен на 0 .

Пример 6 – Първичен ключ върху множество колони

Можете също да създадете първичен ключ на множество колони. Многоколонните първични ключове са известни още като съставни първични ключове. За да създадете съставен първичен ключ, просто разделете колоните със запетая, когато дефинирате ключа.

Като това:

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

Ето пример за ситуация, при която може да се използва първичен ключ с много колони:

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

В този пример BandMember таблицата има първичен ключ от няколко колони. В този случай всяка колона в първичния ключ също е външен ключ към първичния ключ на друга таблица, но това не е изискване.

Вижте Как да създадете композитен първичен ключ в SQL Server за по-подробно обяснение на този пример.

Вижте също как да създадете композитен външен ключ в SQL Server за пример, който отвежда стъпка напред с многоколонен външен ключ, който препраща към горния съставен първичен ключ.