Dans cet article, nous parlerons des contraintes CHECK. Nous verrons comment ajouter des contraintes CHECK aux colonnes de la table SQL Server et discuterons des pièges que vous pouvez rencontrer lors de l'utilisation de ce type de contraintes SQL Server.
Principes de base de la contrainte CHECK
Les contraintes CHECK sont simplement des instructions conditionnelles (prédicats qui renvoient TRUE ou FALSE) qui font référence à des colonnes de table pour maintenir l'intégrité des données. Lorsque l'on insère des données dans une colonne ou plusieurs colonnes dans une seule ligne, les contraintes CHECK entrent en action. Ils évaluent les données à insérer. Si les données ne remplissent pas la condition spécifiée dans la contrainte CHECK, l'insertion échoue.
Considérez l'exemple suivant :
Il est nécessaire de définir une restriction sur la colonne Salaire afin qu'elle ne stocke que des valeurs positives ne dépassant pas 150 000 $. L'énoncé conditionnel ressemblera à ceci :(Salaire>=0 et Salaire <=150000). Lors de la tentative d'insertion de valeurs négatives, le prédicat donnera FALSE et l'insertion échouera.
Il est possible d'ajouter une contrainte CHECK à une ou plusieurs colonnes. L'ajout d'une contrainte CHECK multi-colonnes peut être implémenté au niveau de la table.
Travailler avec les contraintes CHECK
Comment créer des contraintes CHECK dans SSMS
Dans Explorateur d'objets , accédez à une table requise.
Cliquez avec le bouton droit sur les Contraintes dossier puis c lécher Nouvelle contrainte…
Dans le volet de droite de Vérifier les contraintes boîte de dialogue, cliquez sur Expression puis cliquez sur le bouton points de suspension.
Tapez une expression de contrainte CHECK dans le champ de texte de Check Constraint Expression boite de dialogue. Par exemple, pour autoriser uniquement les codes postaux à sept chiffres dans une colonne Zip, l'expression peut ressembler à ceci :
Dans le Concepteur de tableaux section, vous pouvez configurer les règles pour appliquer la contrainte.
VÉRIFIER la contrainte sur CREATE TABLE
Considérez l'exemple suivant :
Il est nécessaire de créer une table qui stocke des données sur les clients de la banque et de la remplir avec des données de test. Le tableau comprendra les colonnes suivantes :ID client, prénom, nom, statut, téléphone, ville, état et code postal.
Lors de l'élaboration du tableau, nous devons prendre en considération les faits suivants :
Le format ZIP de base se compose de cinq chiffres numériques.
Le numéro de téléphone américain standard est composé de dix chiffres, par exemple (555) 555-1234
Les abréviations à deux lettres sont utilisées pour représenter les divisions politiques des États-Unis pour les adresses postales, le traitement des données, les abréviations générales et à d'autres fins.
La tâche consiste à assurer la cohérence des données pour la table. Il est nécessaire d'interdire l'insertion de numéros de téléphone à 12 chiffres et de zips à 6 chiffres etc. Pour cela, SQL Server nous permet d'ajouter une ou plusieurs contraintes CHECK pour chaque colonne de la table.
Dans la section précédente, nous avons examiné la seule façon de créer une contrainte CHECK dans SSMS. Nous allons maintenant discuter de la façon de créer la contrainte à l'aide de T-SQL.
Le script suivant montre comment créer une contrainte CHECK sur la colonne Zip :
CREATE TABLE Customers
(
Customer_Id tinyint NOT NULL,
[First Name] varchar(50),
[Last Name] varchar(50),
Status varchar(50),
Phone tinyint,
Address varchar(50),
State varchar(50),
Zip tinyint,
Email varchar(50),
[Credit Limit] INT NULL,
CONSTRAINT CK_Zip CHECK (Zip LIKE REPLICATE ('[0-9]', 5)) --Check Constraint Condition
) Maintenant, voyons ce que nous obtenons lorsque nous essayons d'insérer une valeur à 6 chiffres dans la colonne Zip :
INSERT INTO dbo.Customers (Customer_Id, [First Name], [Last Name], Status, Phone, Address, State, Zip, Email) SELECT 1, 'James', 'Madison', 'Mr', 555-555-1234, 'Madison street, 12', 'LA', 123456, NULL GO
L'insertion échoue et SQL Server affiche la prévention suivante :
Jusqu'à présent, tout va bien.
Expression CASE dans la contrainte CHECK
Supposons que la banque ait une règle commerciale pour fixer la limite de crédit pour les résidents de l'État de Louisiane à moins de 150 000 USD. Nous allons implémenter cette exigence en ajoutant une contrainte CHECK à la colonne Credit Limit :
ALTER TABLE dbo.Customers ADD CONSTRAINT CK_Credit_Limit CHECK (State='LA' AND [Credit Limit] <= 150000) GO INSERT INTO Customers (Customer_Id, Name, Status, Phone, State, Zip, Email, [Credit Limit]) VALUES (1, 'James Black', 'Mr', 5558787, 'LA', 46853, '[email protected]', 120000); GO INSERT INTO Customers (Customer_Id, Name, Status, Phone, State, Zip, Email, [Credit Limit]) VALUES (2, 'Mark Spencer', 'Mr', 3332244, 'NY', 23487, '[email protected]', 200000); GO
Lorsque nous exécutons l'instruction ci-dessus, nous obtenons l'erreur suivante :
L'instruction INSERT est en conflit avec la contrainte CHECK. Que s'est-il passé ?
Regardons de plus près la requête. Notez que la contrainte CHECK n'autorise que les valeurs "LA" pour la colonne State. Dans le même temps, les valeurs de la colonne Crédit ne doivent pas dépasser 150 000.
De même, la contrainte CHECK ne permettrait pas d'écrire d'autres codes d'état dans la colonne.
Ainsi, nous devons modifier la condition. Selon la logique commerciale, la banque fournit 150 000 $ de la limite de crédit aux résidents de la Louisiane. Dans le même temps, cette valeur peut varier pour les autres résidents.
Pour implémenter ce cas, nous allons utiliser la clause CASE à l'intérieur de la contrainte CHECK :
ALTER TABLE dbo.Customers ADD CONSTRAINT CK_Credit_Limit CHECK (CASE WHEN State='LA' AND [Credit Limit] <= 150000 THEN 1 ELSE 0 END = 1) GO
Cette expression répond parfaitement à la logique métier.
Valeurs NULL dans la contrainte CHECK
La banque divise ses clients en segments. La colonne Statut contient les données qui déterminent si un client est VIP ou régulier. Le montant maximal de la limite de crédit pour les clients réguliers est de 200 000 $. Les VIP peuvent tirer 500 000 $.
La contrainte CHECK peut ressembler à ceci :
ALTER TABLE dbo.Customers ADD CONSTRAINT CK_Status_Credit_Limit CHECK (Status = 'VIP' OR Status = 'Regular') GO
Notez que la contrainte CHECK permet d'insérer des valeurs NULL dans la colonne State (à condition qu'aucune contrainte NOT NULL ne soit explicitement définie). La contrainte CHECK évalue les valeurs et renvoie TRUE ou FALSE. Il évalue NULL comme UNKNOWN. Par conséquent, les valeurs NULL ne provoqueront pas d'erreurs. Ceci est contraire aux prédicats dans les clauses WHERE des instructions SELECT ou UPDATE.
VÉRIFIER et NONVÉRIFIER
De temps en temps, la logique métier change. Cela provoque des modifications des objets de la base de données. Imaginez qu'un pays étende la base du code postal et ajoute des valeurs à 6 chiffres.
Les anciennes valeurs à 5 chiffres ne seront plus attribuées aux zones. Cependant, ils sont toujours valables pour ceux qui existent déjà. Ainsi, la contrainte CHECK doit prendre en compte les données existantes dans l'ancien format, et valider les données dans le nouveau format.
La clause NOCHECK résout ce problème :
ALTER TABLE Customers WITH NOCHECK
ADD CONSTRAINT CK_Zip_Code
CHECK (Zip LIKE REPLICATE('[0-9]', 6));
GO L'insertion suivante est réussie :
INSERT INTO Customers (Customer_Id, Name, Status, Phone, State, Zip, Email, [Credit Limit]) VALUES (102, 'Jake Harrison', 'VIP', 555-555-1234, 'NY', 123456, '[email protected]', 100000); GO
Lorsque vous essayez d'insérer un code postal à cinq chiffres, le moteur renvoie l'erreur :
Contraintes de vérification DBCC
SQL Server fournit DBCC CHECKCONSTRAINTS pour rechercher des données qui ne correspondent pas aux contraintes.
En cas de problème d'intégrité de la base de données, exécutez DBCC CHECKCONSTRAINTS pour l'ensemble de la base de données afin de vous assurer qu'il n'y a aucun problème.
Notez que cette commande affecte les performances. Par conséquent, il ne doit pas être exécuté de manière planifiée.
Il est possible d'exécuter DBCC CHECKCONSTRAINTS pour une seule contrainte, une table ou la base de données entière.
Par rapport aux autres commandes de vérification, DBCC CHECKCONSTRAINTS prend beaucoup de temps et consomme des ressources système. Contrairement à d'autres commandes, CHECKCONSTRAINTS n'utilise pas d'instantané de base de données.
Conclusion
Les contraintes CHECK fournissent le mécanisme d'évaluation des données avant l'insertion. Les contraintes CHECK peuvent faire référence à une seule colonne ou à plusieurs colonnes de table.
Les contraintes sont simplement des prédicats qui donnent VRAI, FAUX ou INCONNU. Dans le cas où NULL est inséré dans une table, une contrainte n'est pas violée.
