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

Une clé primaire composite est une clé primaire composée de plusieurs colonnes. Microsoft les appelle généralement clés primaires multicolonnes dans sa documentation.

Cet article fournit un exemple de création d'une clé primaire composite à l'aide de Transact-SQL dans SQL Server.

Vous pouvez créer une clé primaire composite comme vous créeriez une seule clé primaire, sauf qu'au lieu de spécifier une seule colonne, vous fournissez le nom de deux colonnes ou plus, séparées par une virgule.

Comme ceci :

CONSTRAINT PK_Name CLÉ PRIMAIRE (Colonne1, Colonne2)

Exemple 1 - Créer une clé primaire composite

Voici un exemple de base de données utilisant une clé primaire composite.

Pour les besoins de cet exemple, je vais créer une base de données appelée PK_Test :

CRÉER BASE DE DONNÉES PK_Test ;

Maintenant que la base de données est créée, allons-y et créons les tables.

USE PK_Test;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 CLÉ (MusicianId) RÉFÉRENCES Musicien(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.

Le raisonnement derrière la conception de la base de données ci-dessus est qu'un musicien pourrait potentiellement être membre de nombreux groupes. De plus, chaque groupe peut avoir plusieurs musiciens. Nous avons donc une relation plusieurs à plusieurs. C'est pourquoi le BandMember table est créée – elle est utilisée comme table de concordance entre le Musician table et la Band table.

Ce cas particulier prend en charge une clé primaire composite, car un musicien faisant partie d'un groupe devrait être une occurrence unique. En d'autres termes, nous ne voudrions pas plusieurs lignes avec un musicien membre du même groupe. Cela violerait l'intégrité des données. Cela pourrait également causer des ravages en essayant de maintenir l'intégrité référentielle même si nous créons un jour une relation entre cette table et une autre (ce que nous faisons ici).

Exemple 2 – Insérer des données

Après avoir exécuté le code ci-dessus, je peux maintenant charger la base de données avec des données :

INSERT INTO MusicianVALUES ( 1, 'Ian', 'Paice' ),( 2, 'Roger', 'Glover' ),( 3, 'Richie', 'Blackmore' ),( 4, 'Rod', ' Evans' ),( 5, 'Ozzy', 'Osbourne' );INSERT INTO BandVALUES ( 1, 'Deep Purple' ),( 2, 'Rainbow' ),( 3, 'Whitesnake' ),( 4, 'Iron Maiden ' );INSERT INTO BandMemberVALUES ( 1, 1 ),( 1, 3 ),( 2, 1 ),( 2, 2 ),( 3, 1 ),( 3, 2 ),( 4, 1 ); 
Exemple 3 – Requête de base
 

 Maintenant que les données sont dans notre base de données, exécutons une requête pour renvoyer certaines de ces données.
 

 Voici une requête de base :
 
SELECT CONCAT(m.FirstName, ' ', m.LastName) AS 'Musician', b.BandName AS 'Band'FROM Musician mJOIN BandMember bm ON m.MusicianId =bm.MusicianIdJOIN Band b ON b.BandId =bm .BandId AND m.MusicianId =bm.MusicianId ;
 

 Résultat :
 
+------------------+-------------+| Musicien | Bande ||------------------+-------------|| Ian Paice | Violet profond || Ian Paice | Serpent blanc || Roger Glover | Violet profond || Roger Glover | Arc-en-ciel || Richie Blackmore | Violet profond || Richie Blackmore | Arc-en-ciel || Rod Evans | Violet Profond |+------------------+-------------+
 

 Donc, comme prévu, cela ne renvoie que les musiciens et les groupes qui ont une entrée dans le BandMember table de référence.
 
Exemple 4 – Requête légèrement modifiée
 

 Voici une version modifiée de la requête ci-dessus qui présente les résultats d'une manière différente :
 
SELECT b.BandName AS 'Band', STRING_AGG(CONCAT(m.FirstName, ' ', m.LastName), ', ') AS 'Musicians'FROM Musician mJOIN BandMember bm ON m.MusicianId =bm.MusicianIdJOIN Band b ON b.BandId =bm.BandId AND m.MusicianId =bm.MusicianIdGROUP BY b.BandName ;
 

 Résultat :
 
+-------------+--------------------------------------------- ----------------------+| Bande | Musiciens ||-------------+--------------------------------- ---------------------|| Violet profond | Ian Paice, Roger Glover, Richie Blackmore, Rod Evans || Arc-en-ciel | Roger Glover, Richie Blackmore || serpent blanc | Ian Paice |+-------------+--------------------------------------------- ----------------------+
 

 Ici, les résultats sont regroupés par groupe, et tous les musiciens de chaque groupe sont tous affichés sous forme de liste séparée par des virgules dans un seul champ.
 

 Pour ce faire, j'utilise le STRING_AGG() fonction de concaténation des musiciens. 
 
Clé étrangère composite
 

 Le problème avec l'exemple ci-dessus est que la plupart des données sont obsolètes. Certains de ces musiciens ont en fait quitté ces groupes. Et certains sont partis puis sont revenus plus tard. 
 

 Comment pouvons-nous gérer cela ?
 

 Nous pourrions créer une autre table de référence pour enregistrer la période pendant laquelle chaque musicien est membre de chaque groupe. Une telle table devrait référencer le BandMember table via une clé étrangère. Et vu que cette table a une clé primaire composite, nous aurions besoin d'utiliser une clé étrangère composite sur la nouvelle table qui y fait référence.
 

 Voir Comment créer une clé étrangère composite dans SQL Server pour un exemple. Cet article utilise le même exemple que ci-dessus, sauf avec une table supplémentaire avec une clé étrangère composite qui fait référence à la clé primaire composite ci-dessus.