Database
 sql >> Base de données >  >> RDS >> Database

Créer une relation en SQL

En SQL, vous créez une relation en créant une contrainte de clé étrangère.

Plus précisément, vous avez une table parent et une table enfant. Le parent contient la clé primaire et la table enfant contient une clé étrangère qui fait référence à la clé primaire de la table parent.

Lorsque vous utilisez SQL pour créer une relation, vous pouvez créer la relation au moment où vous créez la table, ou vous pouvez la créer plus tard (en modifiant la table). Cet article couvre les deux scénarios.

Créer une relation lors de la création de la table

Voici un exemple de création d'une relation dans votre CREATE TABLE déclaration au moment où vous créez la table.

CREATE TABLE Parent (
  ParentId int IDENTITY(1,1) NOT NULL PRIMARY KEY,
  ParentName nvarchar(255) NOT NULL
)
CREATE TABLE Child (
  ChildId int IDENTITY(1,1) NOT NULL PRIMARY KEY,
  ChildName nvarchar(255) NOT NULL,
  ParentId int NOT NULL
  CONSTRAINT FK_Child_Parent FOREIGN KEY (ParentId)     
    REFERENCES Parent (ParentId)
);

Ici, j'ai créé deux tables; un appelé Parent et l'autre appelé Child .

J'ai créé la relation dans la définition de table pour l'enfant. La relation est créée avec la CONSTRAINT argument. Notez que ceci est toujours à l'intérieur du CREATE TABLE déclaration.

La relation a besoin d'un nom. Dans ce cas, je l'ai appelé FK_Child_Parent . La FOREIGN KEY part est suivi du nom de la colonne (dans la table enfant) qui sera la clé étrangère.

Les REFERENCES part spécifie la colonne à laquelle la clé étrangère fera référence. Dans ce cas, il fait référence au ParentId colonne du Parent table. Ceci est fait en utilisant REFERENCES Parent (ParentId) .

C'est tout ce qui est nécessaire pour créer la relation.

Notez que les exemples de cette page ont été réalisés à l'aide de SQL Server. En fonction de votre SGBD, vous devrez peut-être modifier certains détails des définitions de colonne.

Par exemple IDENTITY est la version de SQL Server de ce qui est parfois appelé AUTO_INCREMENT dans d'autres SGBD (comme MySQL). Si vous utilisez SQLite, voici comment créer une colonne auto-incrémentée dans SQLite.

Ajouter une relation à une table existante

Vous pouvez également ajouter une relation à une table existante, simplement en utilisant le ALTER TABLE déclaration.

Imaginons que nous n'avons pas créé la relation lors de la création des deux tables de l'exemple précédent. Supposons donc que nous ayons fait ceci à la place :

CREATE TABLE Parent (
  ParentId int IDENTITY(1,1) NOT NULL PRIMARY KEY,
  ParentName nvarchar(255) NOT NULL
)
CREATE TABLE Child (
  ChildId int IDENTITY(1,1) NOT NULL PRIMARY KEY,
  ChildName nvarchar(255) NOT NULL,
  ParentId int NOT NULL
);

Donc, dans ce scénario, tout ce que nous avons fait a été de créer deux tables. Aucune relation n'a été créée entre eux.

Maintenant, après avoir créé les tables, nous nous souvenons soudainement "oh putain, j'ai oublié de créer une relation !".

Pas de problème, nous pouvons maintenant faire ceci :

ALTER TABLE Child
  ADD CONSTRAINT FK_Child_Parent FOREIGN KEY (ParentId)     
    REFERENCES Parent (ParentId);

Fait. Nous venons d'ajouter la relation en utilisant les mêmes détails que dans l'exemple précédent.

Notez que SQLite ne prend pas en charge l'ajout de clés étrangères avec ALTER TABLE déclaration. Découvrez comment ajouter une clé étrangère à une table existante dans SQLite pour en savoir plus à ce sujet.

Sur mise à jour/suppression

Par défaut, les relations SQL Server sont créées à l'aide de ON DELETE NO ACTION et ON UPDATE NO ACTION . Par conséquent, les exemples précédents ont été créés à l'aide de ce paramètre.

Cependant, différents SGBD peuvent utiliser d'autres paramètres par défaut.

Dans tous les cas, vous pouvez le spécifier explicitement dans votre code. Nous pouvons donc modifier l'exemple précédent pour qu'il ressemble à ceci :

ALTER TABLE Child
  ADD CONSTRAINT FK_Child_Parent FOREIGN KEY (ParentId)     
    REFERENCES Parent (ParentId)
    ON DELETE NO ACTION    
    ON UPDATE NO ACTION;

Cela signifie en fait que si quelqu'un essayait de supprimer ou de mettre à jour un enregistrement dans la clé primaire, une erreur se produirait et la modification serait annulée. C'est le moyen utilisé par SQL Server pour empêcher toute modification susceptible de rompre l'intégrité référentielle de votre système.

Fondamentalement, la raison pour laquelle vous créez une relation en premier lieu est d'appliquer l'intégrité référentielle.

Cependant, vous avez quelques options sur la façon dont vous souhaitez que SQL Server gère ces situations.

Plus précisément, vous pouvez utiliser l'une des valeurs suivantes :

  • NO ACTION  :Une erreur est générée et l'action de suppression/mise à jour sur la ligne de la table parent est annulée.
  • CASCADE  :les lignes correspondantes sont supprimées/mises à jour dans la table de référence si cette ligne est supprimée/mise à jour dans la table parent.
  • SET NULL :Toutes les valeurs qui composent la clé étrangère sont définies sur NULL si la ligne correspondante dans la table parent est supprimée ou mise à jour. Cela nécessite que les colonnes de clé étrangère acceptent les valeurs NULL.
  • SET DEFAULT :Toutes les valeurs qui composent la clé étrangère sont définies sur leurs valeurs par défaut si la ligne correspondante dans la table parent est supprimée ou mise à jour. Pour que cette contrainte s'exécute, toutes les colonnes de clé étrangère doivent avoir des définitions par défaut. Si une colonne est nullable et qu'aucune valeur par défaut explicite n'est définie, NULL devient la valeur par défaut implicite de la colonne.