Jak vytvořit primární klíč v SQL Server (příklady T-SQL)

Tento článek ukazuje, jak vytvořit primární klíč v SQL Server při vytváření tabulky pomocí Transact-SQL.

Primární klíč je jeden nebo více sloupců, které byly nakonfigurovány jako jedinečný identifikátor pro danou tabulku. Primární klíče lze použít k vynucení integrity dat v tabulce.

Tabulka může mít pouze jeden primární klíč a primární klíče lze přidat pouze do sloupců, které jsou definovány jako NOT NULL .

Tento článek ukazuje, jak vytvořit primární klíč v novém tabulky (tedy při vytváření tabulky). Pokud potřebujete vytvořit primární klíč v existující tabulka, viz Jak přidat primární klíč do existující tabulky na SQL Server.

Příklad 1 – Vytvoření tabulky s primárním klíčem

Nejprve vytvořím testovací databázi:

CREATE DATABASE PK_Test;

Nyní vytvořte novou tabulku, která obsahuje omezení primárního klíče:

USE PK_Test;

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

Tím byla vytvořena nová tabulka s názvem Colors který má omezení primárního klíče na svém ColorId sloupec.

Příklad 2 – Zkontrolujte omezení primárního klíče

Můžeme spustit následující kód, abychom vrátili seznam omezení primárního klíče v databázi:

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

Výsledek:

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

Pro tento příklad jsem zúžil sloupce. sys.key_constraints systémové zobrazení vrátí více sloupců než toto. Vždy můžete použít * zástupný znak, chcete-li vrátit všechny sloupce.

Z výsledku dotazu můžeme vidět, že tato databáze má pouze jeden primární klíč (ten, který jsme právě vytvořili).

V tomto případě byl primární klíč automaticky pojmenován systémem. Máte také možnost uvést své vlastní jméno (o tom později).

Příklad 3 – Kontrola indexu

Ve výchozím nastavení se při vytvoření primárního klíče vytvoří seskupený index. Clusterový index můžete zadat explicitně nebo jej nechat vytvořit automaticky. Máte také možnost zadat index bez klastrů.

Zde je dotaz, který vrací index, který byl vytvořen automaticky, když jsem vytvořil výše uvedený primární klíč:

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

Výsledek (při použití vertikálního výstupu):

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

V tomto případě jsem zúžil výsledky pouze na řádek, který obsahuje stejný název primárního klíče, který jsem právě vytvořil. WHERE můžete kdykoli odstranit klauzule, pokud potřebujete vrátit více výsledků.

Vidíme, že tento index má type_desc z CLUSTERED .

Příklad 4 – Pojmenování primárního klíče

Primární klíč, který jsme vytvořili výše, byl automaticky pojmenován systémem. Pokud chcete, můžete uvést své vlastní jméno.

Zde je příklad zadání názvu primárního klíče. V tomto případě také specifikuji index bez klastrů.

USE PK_Test;

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

V tomto případě používám volitelný CONSTRAINT klíčové slovo pro označení začátku definice primárního klíče, za nímž následuje mnou zvolený název primárního klíče. Také používám NONCLUSTERED klíčové slovo pro určení, že se jedná o index bez seskupení.

Zkontrolujte primární klíč:

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

Výsledek:

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

Zkontrolujte index:

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

Výsledek (při použití vertikálního výstupu):

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

Takže vidíme, že tentokrát type_desc je NEZAHRNUTÝ .

Všimněte si, že když vytváříte tabulku, CLUSTERED lze zadat pouze pro jedno omezení. Pokud je určen pro UNIQUE omezení a PRIMARY KEY je také specifikováno omezení, PRIMARY KEY výchozí hodnota je NONCLUSTERED .

Příklad 5 – Vytvoření primárního klíče ve sloupci s možnou hodnotou Null

Primární klíč lze vytvořit pouze pro sloupce, které jsou definovány jako NOT NULL . Pokud se pokusíte vytvořit primární klíč ve sloupci, který je nastaven na NULL , zobrazí se chyba.

Pokud však možnost null neurčíte, sloupec bude nastaven na NOT NULL ve výchozím nastavení.

Abychom to demonstrovali, vytvořte další tabulku, ale tentokrát ji nastavíme na NULL :

USE PK_Test;

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

Výsledek:

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.

Jak se očekávalo, dostaneme chybu.

Odstraníme NULL z definice tabulky a zkuste to znovu:

USE PK_Test;

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

Výsledek:

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

Tentokrát byla tabulka úspěšně vytvořena.

Pojďme se na to podívat:

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

Výsledek:

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

Takže vidíme, že to není možné nulovat, protože is_nullable příznak je nastaven na 0 .

Příklad 6 – Primární klíč ve více sloupcích

Můžete také vytvořit primární klíč pro více sloupců. Vícesloupcové primární klíče jsou také známé jako složené primární klíče. Chcete-li vytvořit složený primární klíč, jednoduše při definování klíče oddělte sloupce čárkou.

Takhle:

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

Zde je příklad situace, kdy lze použít vícesloupcový primární klíč:

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

V tomto příkladu BandMember tabulka má vícesloupcový primární klíč. V tomto případě je každý sloupec v primárním klíči také cizím klíčem primárního klíče jiné tabulky, ale není to podmínkou.

Podrobnější vysvětlení tohoto příkladu naleznete v části Jak vytvořit složený primární klíč v SQL Server.

Viz také Jak vytvořit složený cizí klíč v SQL Server, kde najdete příklad, který to posune o krok dále s vícesloupcovým cizím klíčem, který odkazuje na výše uvedený složený primární klíč.