Explorer les différentes contraintes dans SQL Server

Les contraintes dans SQL Server sont des règles prédéfinies que vous pouvez appliquer sur une ou plusieurs colonnes. Ces contraintes aident à maintenir l'intégrité, la fiabilité et l'exactitude des valeurs stockées dans ces colonnes. Vous pouvez créer des contraintes à l'aide des instructions CREATE TABLE ou ALTER Table. Si vous utilisez l'instruction ALTER TABLE, SQL Server vérifiera les données de la colonne existante avant de créer la contrainte.

Si vous insérez des données dans la colonne qui répondent aux critères de la règle de contrainte, SQL Server insère correctement les données. Cependant, si les données violent la contrainte, l'instruction d'insertion est abandonnée avec un message d'erreur.

Par exemple, supposons que vous ayez une table [Employee] qui stocke les données des employés de votre organisation, y compris leur salaire. Il existe quelques règles empiriques en ce qui concerne les valeurs dans la colonne des salaires.

• La colonne ne peut pas contenir de valeurs négatives telles que -10 000 ou -15 000 USD.
• Vous souhaitez également spécifier la valeur salariale maximale. Par exemple, le salaire maximum doit être inférieur à 2 000 000 USD.

Si vous insérez un nouvel enregistrement avec une contrainte en place, SQL Server validera la valeur par rapport aux règles définies.

Valeur insérée :

Salaire 80 000 :inséré avec succès

Salaire -50 000 : Erreur

Nous allons explorer les contraintes suivantes dans SQL Server dans cet article.

• NON NULL
• UNIQUES
• VÉRIFIER
• CLÉ PRIMAIRE
• CLÉ ÉTRANGÈRE
• PAR DÉFAUT

Contrainte NOT NULL

Par défaut, SQL Server permet de stocker des valeurs NULL dans des colonnes. Ces valeurs NULL ne représentent pas des données valides.

Par exemple, chaque employé d'une organisation doit avoir un ID Emp, un prénom, un sexe et une adresse. Par conséquent, vous pouvez spécifier une colonne avec des contraintes NOT NULL pour toujours garantir des valeurs valides.

Le script CREATE TABLE ci-dessous définit les contraintes NOT NULL pour les colonnes [ID], [FirstName], [LastName], [Gender] et [Address].

CREATE TABLE Employees
(
ID INT NOT NULL,
[FirstName] Varchar(100) NOT NULL,
[MiddleName] Varchar(50) NULL,
[LastName] Varchar(100) NOT NULL,
[Gender] char(1) NOT NULL,
[Address] Varchar(200) NOT NULL
)

Pour valider les contraintes NOT NULL, comportement, nous utilisons les instructions INSERT suivantes.

• Insérer des valeurs pour toutes les colonnes (NULL et NOT NULL) – Inserts avec succès

INSERT INTO Employees (ID,[FirstName],[MiddleName],[LastName],[gender],[Address]) VALUES(1,'Raj','','Gupta','M','India')

• Insérer des valeurs pour les colonnes avec la propriété NOT NULL – Inserts avec succès

INSERT INTO Employees (ID,[FirstName],[LastName],[gender],[Address]) VALUES(2,
'Shyam','Agarwal','M','UK')

• Ignorer l'insertion de valeurs pour la colonne [LastName] ayant des contraintes NOT NULL – Échec+

INSERT INTO Employees (ID,[FirstName],[gender],[Address]) VALUES(3,'Sneha','F','India')

La dernière instruction INSERT a généré l'erreur : Impossible d'insérer des valeurs NULL dans la colonne .

Cette table contient les valeurs suivantes insérées dans la table [Employés].

Supposons que nous n'ayons pas besoin de valeurs NULL dans la colonne [MiddleName] conformément aux exigences des ressources humaines. À cette fin, vous pouvez utiliser l'instruction ALTER TABLE.

ALTER TABLE Employees
ALTER COLUMN [MiddleName] VARCHAR(50) NOT NULL

Cette instruction ALTER TABLE échoue en raison des valeurs existantes de la colonne [MiddleName]. Pour appliquer la contrainte, vous devez éliminer ces valeurs NULL, puis exécuter l'instruction ALTER.

UPDATE Employees SET [MiddleName]='' WHERE [MiddleName] IS NULL
Go
ALTER TABLE Employees
ALTER COLUMN [MiddleName] VARCHAR(50) NOT NULL

Vous pouvez également valider les contraintes NOT NULL à l'aide du concepteur de table SSMS.

Contrainte UNIQUE

La contrainte UNIQUE dans SQL Server garantit que vous n'avez pas de valeurs en double dans une seule colonne ou combinaison de colonnes. Ces colonnes doivent faire partie des contraintes UNIQUE. SQL Server crée automatiquement un index lorsque des contraintes UNIQUE sont définies. Vous ne pouvez avoir qu'une seule valeur unique dans la colonne (y compris NULL).

Par exemple, créez le [DemoTable] avec la colonne [ID] ayant la contrainte UNIQUE.

CREATE TABLE DemoTable
(
[ID] INT UNIQUE NOT NULL,
[EmpName] VARCHAR(50) NOT NULL
)

Ensuite, développez la table dans SSMS et vous obtenez un index unique (non clusterisé), comme indiqué ci-dessous.

Veuillez faire un clic droit sur l'index et générer son script. Comme indiqué ci-dessous, il utilise le mot-clé ADD UNIQUE NONCLUSTERED pour la contrainte.

L'instruction d'insertion suivante génère une erreur car elle tente d'insérer des valeurs en double.

INSERT INTO DemoTable ([ID],[EmpName]) VALUES (1,'Raj')
GO
INSERT INTO DemoTable ([ID],[EmpName]) VALUES (2,'Alisha')
GO
INSERT INTO DemoTable ([ID],[EmpName]) VALUES (1,'Raj')
GO

Contrainte CHECK

La contrainte CHECK dans SQL Server définit une plage valide de valeurs pouvant être insérées dans des colonnes spécifiées. Il évalue chaque valeur insérée ou modifiée, et si elle est satisfaite, l'instruction SQL est terminée avec succès.

Le script SQL suivant place une contrainte pour la colonne [Age]. Sa valeur doit être supérieure à 18 ans.

CREATE TABLE DemoCheckConstraint
(
ID INT PRIMARY KEY,
[EmpName] VARCHAR(50) NULL,
[Age] INT CHECK (Age>18)
)
GO

Insérons deux enregistrements dans cette table. La requête insère le premier enregistrement avec succès.

INSERT INTO DemoCheckConstraint (ID,[EmpName],[Age])VALUES (1,'Raj',20)
Go
INSERT INTO DemoCheckConstraint (ID,[EmpName],[Age])VALUES (2,'Sohan',17)
GO

La deuxième instruction INSERT échoue car elle ne satisfait pas la condition de contrainte CHECK.

Un autre cas d'utilisation de la contrainte CHECK consiste à stocker des valeurs valides de codes postaux. Dans le script ci-dessous, nous ajoutons une nouvelle colonne [ZipCode] et elle utilise la contrainte CHECK pour valider les valeurs.

ALTER TABLE DemoCheckConstraint ADD zipcode int
GO
ALTER TABLE DemoCheckConstraint
ADD CONSTRAINT CK_zipcode CHECK (zipcode LIKE REPLICATE ('[0-9]', 5))

Cette contrainte CHECK n'autorise pas les codes postaux invalides. Par exemple, la deuxième instruction INSERT génère une erreur.

INSERT INTO DemoCheckConstraint values(3,'Sneha',19,30203)
Go
INSERT INTO DemoCheckConstraint values(4,'Jenny',21,122102)

Contrainte PRIMARY KEY

La contrainte PRIMARY KEY dans SQL Server est un choix populaire parmi les professionnels des bases de données pour implémenter des valeurs uniques dans une table relationnelle. Il combine les contraintes UNIQUE et NOT NULL. SQL Server crée automatiquement un index cluster une fois que nous avons défini une contrainte PRIMARY KEY. Vous pouvez utiliser une seule colonne ou un ensemble de combinaisons pour définir des valeurs uniques dans une ligne.

Son objectif principal est de renforcer l'intégrité de la table à l'aide de la valeur unique de l'entité ou de la colonne.

Elle est similaire à la contrainte UNIQUE avec les différences suivantes.

Le script suivant définit la PRIMARY KEY sur la colonne ID.

CREATE TABLE PrimaryKeyDemo
(
ID INT PRIMARY KEY,
[Name] VARCHAR(100) NULL
)

Comme indiqué ci-dessous, vous disposez d'un index de clé clusterisé après avoir défini la CLÉ PRIMAIRE dans la colonne ID.

Insérons les enregistrements dans la table [PrimaryKeyDemo] avec les instructions INSERT suivantes.

INSERT INTO PrimaryKeyDemo ([ID],[NAME]) VALUES (1,'Raj')
GO
INSERT INTO PrimaryKeyDemo ([NAME]) VALUES ('Mohan')
GO

Vous obtenez une erreur dans la deuxième instruction INSERT car elle tente d'insérer la valeur NULL.

De même, si vous essayez d'insérer des valeurs en double, vous obtenez le message d'erreur suivant.

contrainte FOREIGN KEY

La contrainte FOREIGN KEY dans SQL Server crée des relations entre deux tables. Cette relation est connue sous le nom de relation parent-enfant. Il applique l'intégrité référentielle dans SQL Server.

La clé étrangère de la table enfant doit avoir une entrée correspondante dans la colonne de la clé primaire parente. Vous ne pouvez pas insérer de valeurs dans la table enfant sans l'insérer d'abord dans la table parent. De même, nous devons d'abord supprimer la valeur de la table enfant avant de pouvoir la supprimer de la table parent.

Comme nous ne pouvons pas avoir de valeurs en double dans la contrainte PRIMARY KEY, elle n'autorise pas non plus les doublons ou NULL dans la table enfant.

Le script SQL suivant crée une table parent avec une clé primaire et une table enfant avec une référence de clé primaire et étrangère à la colonne [EmpID] de la table parent.

CREATE TABLE ParentTable
(
[EmpID] INT PRIMARY KEY,
[Name] VARCHAR(50) NULL
)
GO
CREATE TABLE ChildTable
(
[ID] INT PRIMARY KEY,
[EmpID] INT FOREIGN KEY REFERENCES ParentTable(EmpID)
)

Insérez des enregistrements dans les deux tables. Notez que la valeur de clé étrangère de la table enfant a une entrée dans la table parent.

INSERT INTO ParentTable VALUES (1,'Raj'),(2,'Komal')
INSERT INTO ChildTable VALUES (101,1),(102,2)

Si vous essayez d'insérer un enregistrement directement dans la table enfant qui ne fait pas référence à la clé primaire de la table parent, vous obtenez le message d'erreur suivant.

contrainte DEFAULT

La contrainte DEFAULT dans SQL Server fournit la valeur par défaut pour une colonne. Si nous ne spécifions pas de valeur dans l'instruction INSERT pour la colonne avec la contrainte DEFAULT, SQL Server utilise sa valeur attribuée par défaut. Par exemple, supposons qu'une table de commandes contienne des enregistrements pour toutes les commandes des clients. Vous pouvez utiliser la fonction GETDATE() pour capturer la date de la commande sans spécifier de valeur explicite.

CREATE TABLE Orders
(
[OrderID] INT PRIMARY KEY,
[OrderDate] DATETIME NOT NULL DEFAULT GETDATE()
)
GO

Pour insérer les enregistrements dans ce tableau, nous pouvons ignorer l'attribution de valeurs pour la colonne [OrderDate].

INSERT INTO Orders([OrderID]) values (1)
GO

SELECT * FROM Commandes

Une fois que la colonne de contrainte DEFAULT spécifie une valeur explicite, SQL Server stocke cette valeur explicite au lieu de la valeur par défaut.

Bénéfices des contraintes

Les contraintes dans SQL Server peuvent être bénéfiques dans les cas suivants :

• Application de la logique métier
• Application de l'intégrité référentielle
• Éviter le stockage de données incorrectes dans les tables SQL Server
• Imposer l'unicité des données de colonne
• Améliorer les performances des requêtes, car l'optimiseur de requêtes est conscient des données uniques et valide les ensembles de valeurs
• Empêcher le stockage des valeurs NULL dans les tables SQL
• Écrire des codes pour éviter NULL lors de l'affichage des données dans l'application