Clé primaire et clé étrangère dans SQLite avec des exemples

SQLite contraintes

Les contraintes de colonne appliquent des contraintes et des règles aux valeurs insérées sur une colonne afin de valider les données insérées. Les contraintes de colonnes sont définies lors de la création d'une table, dans la définition des colonnes.

SQLite Clé primaire

Toutes les valeurs d'une colonne de clé primaire doivent être uniques et non nulles

La clé primaire peut être appliquée à une seule colonne ou à une combinaison de colonnes, dans ce dernier cas, la combinaison des valeurs des colonnes doit être unique pour toutes les lignes des tables.

syntaxe:

Il existe de nombreuses façons différentes de définir une clé primaire sur une table, comme :

• Dans la définition de la colonne elle-même :

  ColumnName INTEGER NOT NULL PRIMARY KEY;

• Comme définition distincte :

  PRIMARY KEY(ColumnName);

• Pour créer une combinaison de colonnes comme clé primaire :

  PRIMARY KEY(ColumnName1, ColumnName2);

Contrainte non nulle

SQLite La contrainte Not null empêche une colonne d'avoir une valeur nulle :

ColumnName INTEGER  NOT NULL;

Contrainte PAR DÉFAUT

SQLite Contrainte par défaut si vous n'insérez aucune valeur dans une colonne, la valeur par défaut sera insérée à la place.

Par exemple:

ColumnName INTEGER DEFAULT 0;

Si vous écrivez une instruction d'insertion et que vous n'avez spécifié aucune valeur pour cette colonne, la colonne aura la valeur 0.

SQLite Contrainte unique

SQLite Contrainte unique, elle empêchera les valeurs en double parmi toutes les valeurs de la colonne.

Par exemple :

EmployeeId INTEGER NOT NULL UNIQUE;

Cela fera respecter le «Identifiant de l'employé» que la valeur soit unique, aucune valeur dupliquée ne sera autorisée. Notez que cela s'applique aux valeurs de la colonne «Identifiant de l'employé» seulement.

SQLite Contrainte CHECK

SQLite check contraint une condition pour vérifier une valeur insérée, si la valeur ne correspond pas à la condition, elle ne sera pas insérée.

Quantity INTEGER NOT NULL CHECK(Quantity > 10);

Vous ne pouvez pas insérer une valeur inférieure à 10 dans le "Quantité" colonne.

SQLite Clé étrangère

Votre SQLite la clé étrangère est une contrainte qui vérifie l'existence d'une valeur présente dans une table dans une autre table ayant une relation avec la première table où la clé étrangère est définie.

Lorsque vous travaillez avec plusieurs tables, lorsqu'il y a deux tables liées l'une à l'autre avec une colonne en commun. Et si vous voulez vous assurer que la valeur insérée dans l'un d'eux doit exister dans la colonne de l'autre table, alors vous devez utiliser une « Contrainte de clé étrangère » sur la colonne en commun.

Dans ce cas, lorsque vous essayez d'insérer une valeur sur cette colonne, la clé étrangère garantira que la valeur insérée existe dans la colonne de la table.

Notez que les contraintes de clés étrangères ne sont pas activées par défaut dans SQLite, vous devez d'abord les activer en exécutant la commande suivante :

PRAGMA foreign_keys = ON;

Des contraintes de clé étrangère ont été introduites dans SQLite à partir de la version 3.6.19.

Exemple de SQLite Clé étrangère

Supposons que nous ayons deux tables ; Étudiants et départements.

La table Étudiants contient une liste d'étudiants et la table Départements contient une liste des départements. Chaque étudiant appartient à un département ; c'est-à-dire que chaque étudiant a une colonne DepartmentId.

Nous allons maintenant voir comment la contrainte de clé étrangère peut être utile pour garantir que la valeur de l'identifiant du département dans la table des étudiants doit exister dans la table des départements.

Ainsi, si nous créons une contrainte de clé étrangère sur le DepartmentId de la table Students, chaque DepartmentId inséré doit être présent dans la table Departments.

CREATE TABLE [Departments] (
	[DepartmentId] INTEGER  NOT NULL PRIMARY KEY AUTOINCREMENT,
	[DepartmentName] NVARCHAR(50)  NULL
);
CREATE TABLE [Students] (
	[StudentId] INTEGER  PRIMARY KEY AUTOINCREMENT NOT NULL,
	[StudentName] NVARCHAR(50)  NULL,
	[DepartmentId] INTEGER  NOT NULL,
	[DateOfBirth] DATE  NULL,
	FOREIGN KEY(DepartmentId) REFERENCES Departments(DepartmentId)
);

Pour vérifier comment les contraintes de clé étrangère peuvent empêcher l'insertion d'un élément ou d'une valeur non définie dans une table ayant une relation avec une autre table, nous examinerons l'exemple suivant.

Dans cet exemple, la table Departments a une contrainte de clé étrangère sur la table Students, donc toute valeur DepartmentId insérée dans la table Students doit exister dans la table Departments. Si vous essayez d'insérer une valeur DepartmentId qui n'existe pas dans la table Departments, la contrainte de clé étrangère vous empêchera de le faire.

Insérons deux départements "IL" et « Arts » dans le tableau des départements comme suit :

INSERT INTO Departments VALUES(1, 'IT');
INSERT INTO Departments VALUES(2, 'Arts');

Les deux instructions doivent insérer deux départements dans la table des départements, vous pouvez vous assurer que les deux valeurs ont été insérées en exécutant la requête « SÉLECTIONNER * DES Départements » après ça:

Essayez ensuite d'insérer un nouvel étudiant avec un DepartmentId qui n'existe pas dans la table des départements :

INSERT INTO Students(StudentName,DepartmentId) VALUES('John', 5);

La ligne ne sera pas insérée et vous obtiendrez une erreur indiquant que : La contrainte FOREIGN KEY a échoué.