Comment créer une clé primaire dans SQL Server (exemples T-SQL)

Cet article montre comment créer une clé primaire dans SQL Server lors de la création d'une table à l'aide de Transact-SQL.

Une clé primaire est une ou plusieurs colonnes qui ont été configurées comme identifiant unique pour une table donnée. Les clés primaires peuvent être utilisées pour renforcer l'intégrité des données dans la table.

Une table ne peut avoir qu'une seule clé primaire, et les clés primaires ne peuvent être ajoutées qu'aux colonnes définies comme NOT NULL .

Cet article montre comment créer une clé primaire dans un nouveau table (c'est-à-dire lors de la création de la table). Si vous avez besoin de créer une clé primaire dans un existant table, consultez Comment ajouter une clé primaire à une table existante dans SQL Server.

Exemple 1 - Créer une table avec une clé primaire

Je vais d'abord créer une base de données de test :

CREATE DATABASE PK_Test;

Créez maintenant une nouvelle table qui inclut une contrainte de clé primaire :

USE PK_Test;

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

Cela a créé une nouvelle table appelée Colors qui a une contrainte de clé primaire sur son ColorId colonne.

Exemple 2 - Vérifier la contrainte de clé primaire

Nous pouvons exécuter le code suivant pour renvoyer une liste de contraintes de clé primaire dans la base de données :

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

Résultat :

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

J'ai réduit les colonnes pour cet exemple. Les sys.key_constraints la vue système renvoie plus de colonnes que cela. Vous pouvez toujours utiliser le * caractère générique pour renvoyer toutes les colonnes si vous le souhaitez.

Nous pouvons voir par le résultat de la requête que cette base de données n'a qu'une seule clé primaire (celle que nous venons de créer).

Dans ce cas, la clé primaire a été automatiquement nommée par le système. Vous avez également la possibilité de fournir votre propre nom (plus à ce sujet plus tard).

Exemple 3 - Vérifier l'index

Par défaut, un index clusterisé est créé lorsque vous créez la clé primaire. Vous pouvez spécifier explicitement l'index clusterisé ou le laisser être créé automatiquement. Vous avez également la possibilité de spécifier un index non clusterisé.

Voici une requête qui renvoie l'index qui a été créé automatiquement lorsque j'ai créé la clé primaire ci-dessus :

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

Résultat (en utilisant la sortie verticale) :

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

Dans ce cas, j'ai réduit les résultats à la ligne contenant le même nom que la clé primaire que je viens de créer. Vous pouvez toujours supprimer le WHERE clause si vous avez besoin de plus de résultats à renvoyer.

Nous pouvons voir que cet index a un type_desc de CLUSTERED .

Exemple 4 - Nommer la clé primaire

La clé primaire que nous avons créée ci-dessus a été automatiquement nommée par le système. Vous pouvez fournir votre propre nom si vous préférez.

Voici un exemple de spécification d'un nom pour la clé primaire. Dans ce cas, je spécifie également un index non clusterisé.

USE PK_Test;

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

Dans ce cas, j'utilise l'option CONSTRAINT mot-clé pour indiquer le début de la définition de la clé primaire, suivi du nom que j'ai choisi pour la clé primaire. J'utilise aussi le NONCLUSTERED mot-clé pour spécifier qu'un index non clusterisé.

Vérifiez la clé primaire :

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

Résultat :

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

Vérifiez l'index :

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

Résultat (en utilisant la sortie verticale) :

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

Nous pouvons donc voir que cette fois le type_desc est NON CLUSTÉRÉ .

Notez que lors de la création d'une table, CLUSTERED peut être spécifié pour une seule contrainte. S'il est spécifié pour un UNIQUE contrainte et une PRIMARY KEY contrainte est également spécifiée, la PRIMARY KEY par défaut à NONCLUSTERED .

Exemple 5 - Créer une clé primaire sur une colonne Nullable

Une clé primaire ne peut être créée que pour les colonnes définies comme NOT NULL . Si vous essayez de créer une clé primaire sur une colonne définie sur NULL , vous obtiendrez une erreur.

Cependant, si vous ne spécifiez pas la nullabilité, la colonne est définie sur NOT NULL par défaut.

Pour illustrer cela, créons une autre table, mais cette fois, nous la définirons sur NULL :

USE PK_Test;

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

Résultat :

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.

Comme prévu, nous obtenons une erreur.

Supprimons NULL à partir de la définition de table et réessayez :

USE PK_Test;

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

Résultat :

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

Cette fois, la table a été créée avec succès.

Jetons-y un coup d'œil :

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

Résultat :

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

Nous pouvons donc voir que ce n'est pas nullable, car le is_nullable l'indicateur est défini sur 0 .

Exemple 6 - Clé primaire sur plusieurs colonnes

Vous pouvez également créer une clé primaire sur plusieurs colonnes. Les clés primaires multicolonnes sont également appelées clés primaires composites. Pour créer une clé primaire composite, séparez simplement les colonnes par une virgule lors de la définition de la clé.

Comme ceci :

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

Voici un exemple de situation où une clé primaire multicolonne pourrait être utilisée :

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

Dans cet exemple, le BandMember table a une clé primaire multicolonne. Dans ce cas, chaque colonne de la clé primaire est également une clé étrangère vers la clé primaire d'une autre table, mais ce n'est pas obligatoire.

Voir Comment créer une clé primaire composite dans SQL Server pour une explication plus détaillée de cet exemple.

Consultez également Comment créer une clé étrangère composite dans SQL Server pour un exemple qui va plus loin avec une clé étrangère multicolonne qui fait référence à la clé primaire composite ci-dessus.