SQL Server

Clés primaires et clés étrangères dans SQL Server

Découvrez comment les clés primaires identifient les lignes et comment les clés étrangères relient les tables en protégeant leurs relations.

Par JaviPublié 12 min de lectureDébutant

Les bases relationnelles répartissent les informations dans des tables et relient les lignes apparentées avec des colonnes clés. Une clé primaire identifie les lignes d’une table. Une clé étrangère, dans une autre table, fait référence à cet identifiant et permet à SQL Server de protéger la relation. Ces notions existent dans presque toutes les bases réelles, y compris le petit exemple de clients et de commandes de cette leçon.

La base synthétique JaviBuildsLab contient dbo.Customers et dbo.Orders. Chaque client possède une ligne dans Customers et chaque commande une ligne dans Orders. Le lien est Customers.CustomerId → Orders.CustomerId. Cette leçon explique le rôle des clés, la protection des relations et leurs effets sur les JOIN étudiés précédemment.

Rôle d’une clé primaire

Une clé primaire est une contrainte qui identifie chaque ligne d’une table. Sa valeur doit être unique et une colonne de clé primaire ne peut pas être NULL. Si CustomerId est la clé primaire, deux clients ne peuvent pas partager le même identifiant et chaque ligne doit en avoir un.

Dans le schéma de démonstration, CustomerId identifie un client et OrderId une commande. Une requête, une application ou une autre table peut ainsi désigner un enregistrement sans dépendre d’un nom ou d’une adresse susceptibles de changer. « Ana Torres » n’est pas nécessairement un nom unique ; un identifiant stable distingue deux personnes portant le même nom.

La clé primaire est une règle, et pas seulement une colonne dont les valeurs semblent uniques aujourd’hui. SQL Server vérifie cette règle quand on insère ou modifie des lignes. Une clé en double ou une valeur NULL est rejetée. Cette protection s’applique même si les données arrivent de plusieurs applications ou scripts.

Requête SQL: Rôle d’une clé primaireT-SQL
SELECT CustomerId, FirstName, LastName
FROM dbo.Customers
ORDER BY CustomerId;
T-SQL3 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Dans SSMS, développez le dossier Keys de la table dans l’Explorateur d’objets ou ouvrez son concepteur pour examiner les contraintes de clé primaire. Un nom comme PK_Customers l’indique souvent, mais les équipes peuvent choisir d’autres conventions. Consultez la définition ou les propriétés pour confirmer les colonnes exactes.

Rôle d’une clé étrangère

Une clé étrangère est une contrainte d’une table qui référence une clé d’une autre table. Ici, Orders.CustomerId fait référence à Customers.CustomerId. Chaque identifiant client non NULL enregistré sur une commande doit correspondre à une ligne client, sauf si la relation autorise explicitement NULL.

La table parente est la table référencée, soit Customers. La table enfant contient la clé étrangère, soit Orders. Cette direction peut sembler inversée au début, car c’est la commande qui stocke le lien. En pratique, on exprime la relation « cette commande appartient à ce client ». La valeur CustomerId est répétée dans la table enfant afin que plusieurs commandes puissent désigner le même client parent.

  1. Customers.CustomerId PK
  2. 1 client
  3. plusieurs commandes
  4. Orders.CustomerId FK
Un client peut avoir plusieurs commandes

Il s’agit d’une relation un-à-plusieurs : un client peut avoir zéro, une ou plusieurs commandes ; dans cette conception, chaque commande fait référence à un client. Cela n’oblige pas chaque client à avoir déjà commandé. La clé étrangère protège les références enfant effectivement présentes.

L’intégrité référentielle en pratique

L’intégrité référentielle est la règle de cohérence qui maintient la validité des références. Si Orders.CustomerId possède une clé étrangère vers Customers.CustomerId, SQL Server refuse une commande qui référence un identifiant client absent de Customers. Cela empêche une commande orpheline sans parent valide.

Par exemple, CustomerId = 11 est valide si ce client existe. Une valeur comme 99999 est rejetée en l’absence de ligne parente correspondante. La base applique cette règle même lorsque la modification provient d’un autre script ou d’une autre application. C’est plus fiable que de demander à chaque programme de vérifier correctement la relation.

Les valeurs de clé étrangère peuvent se répéter. En fait, c’est ainsi que plusieurs lignes enfant se rattachent au même parent. Si le client 11 possède quatre commandes, les quatre lignes peuvent contenir CustomerId = 11. La clé primaire est unique dans la table parente ; la clé étrangère ne l’est généralement pas dans la table enfant.

La contrainte influence aussi les suppressions et les mises à jour. S’il reste des commandes, la suppression du client peut être refusée afin que les enfants ne perdent pas leur parent valide. Le comportement exact peut être configuré, notamment avec des actions en cascade, mais ces options ont des conséquences et ne s’utilisent pas à la légère. Pour débuter, comprenez d’abord la protection par défaut. La leçon DELETE et le parcours de modification prudent expliquent pourquoi il faut inspecter les dépendances avant de changer des lignes.

Observer la relation avec SQL

La clé étrangère fournit une condition de jointure claire :

Requête SQL: Observer la relation avec SQLT-SQL
SELECT c.CustomerId, c.FirstName, c.LastName,
       o.OrderId, o.OrderDate, o.Amount
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId
ORDER BY c.CustomerId, o.OrderId;
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Cette requête renvoie une ligne pour chaque paire client-commande correspondante. Un client avec plusieurs commandes apparaît sur plusieurs lignes. La répétition de CustomerId dans Orders est attendue et ne viole pas l’unicité de la clé primaire client. Consultez Pourquoi les JOIN produisent des lignes répétées si la forme du résultat vous surprend.

La contrainte de clé rend la relation fiable, mais la requête doit toujours comporter la bonne condition ON. Une clé étrangère ne joint pas automatiquement les tables et ne garantit pas que chaque requête l’utilise. Qualifiez les colonnes et examinez le schéma si vous ne savez pas quelles colonnes sont liées.

Brève note sur les clés composées et naturelles

Certaines tables ont besoin d’une clé composée de plusieurs colonnes. Une hypothétique table de lignes de commande pourrait, par exemple, identifier chaque ligne avec OrderId et LineNumber. Chacune peut se répéter seule, tandis que leur paire reste unique. Ces clés sont utiles lorsque la combinaison constitue l’identité stable, mais elles exigent une attention particulière : les clés étrangères liées doivent transporter chaque partie.

Une clé naturelle vient d’un attribut du monde réel, comme un identifiant officiel ou un code attribué. Une clé de substitution est créée pour la base, par exemple un entier CustomerId. Les valeurs naturelles ont du sens, mais peuvent changer, manquer ou nécessiter une protection de confidentialité. Les identifiants de substitution sont courants parce qu’ils séparent l’identité de la ligne des faits descriptifs de l’activité. Le bon choix dépend du domaine ; aucun des deux noms ne signifie « toujours choisir cela ».

Ne confondez pas un identifiant avec une garantie de justesse des autres informations de la ligne. Une clé primaire peut garantir un ID distinct par client, mais pas l’exactitude de l’orthographe du nom ni de l’adresse. Une contrainte protège une règle précise ; elle ne remplace pas la compréhension des données.

Clés et index

Une clé concerne l’intégrité des données. Un index est une structure qui peut aider SQL Server à trouver des lignes plus efficacement. SQL Server crée souvent un index pour une clé primaire, selon sa définition et les index déjà présents. Une clé étrangère n’implique pas automatiquement que la colonne de référence possède un index. Ces notions sont liées, mais distinctes : un index unique et une contrainte de clé primaire communiquent des règles de conception différentes.

La prochaine leçon présente les index dans SQL Server et leurs compromis de base. Pour l’instant, retenez quel objet protège l’unicité ou une relation et quel objet facilite l’accès aux données.

Exercice dans SSMS

Dans l’Explorateur d’objets, développez JaviBuildsLab, Tables, puis examinez les dossiers Keys de dbo.Customers et dbo.Orders. Repérez la clé primaire CustomerId, celle de OrderId, puis la clé étrangère reliant Orders.CustomerId à Customers.CustomerId. Utilisez les propriétés ou le concepteur pour confirmer les colonnes concernées.

Exécutez l’exemple de jointure et comparez le nombre de lignes au nombre de commandes. Trouvez ensuite un client qui a plusieurs commandes : le même CustomerId doit apparaître plusieurs fois du côté des commandes. Ne tentez pas de supprimer une ligne parente comme essai sur une base partagée. Si vous apprenez sur des données jetables, comprenez le comportement de la contrainte avant toute modification.

  1. PK identifie parent
  2. FK référence clé
  3. SQL Server vérifie le lien
Les clés protègent les relations

Les clés rendent les relations explicites, appliquent des règles utiles et donnent une base claire aux jointures. La prochaine leçon traite des index, qui peuvent aider SQL Server à trouver les lignes, au prix d’espace et de travail supplémentaire lors des écritures : Index dans SQL Server. Retrouvez la séquence entière sur la feuille de route SQL Server Foundations.

Vérifiez ce que vous avez retenu

2 questions rapides

Question 1 sur 2Que permet d’identifier une clé primaire ?
Question 2 sur 2Quelle relation une clé étrangère permet-elle ?

Fondamentaux de SQL Server

Leçon 23 sur 25

Continuer vers la leçon suivante

Index dans SQL Server : une introduction pour débutants

Continuer vers la leçon 24

Étiquettes

  • SQL Server
  • Fondamentaux SQL
  • SSMS
  • T-SQL