Contraintes de Bases de Données

Au lieu de créer un nouveau compte chaque fois que le client souhaite effectuer une nouvelle transaction, vous pouvez utiliser un compte comme une référence et amener ce compte chaque fois que le client souhaite déposer ou retirer de l'argent.

Pour appliquer les règles de bases de données relationnelles, vous devez créer certains types de relations entre les objets de la base de données.

Les transactions entre les divers objets d'une base de données doivent s'assurer que l'information d'un objet est accessible à un autre objet. Les objets qui contiennent des informations, comme nous l'avons déjà mentionné, sont les tables.

Pour gérer le flux d'informations d'une table (A) à une autre table (B), la table qui contient les information A, doit les rendre disponibles aux autres tables, telle que B. Il existe diverses questions qui doivent être traitées :

1. Vous devez être en mesure d'identifier de manière unique, chaque enregistrement d'une table (A) sans toute confusion. Par exemple, si vous créez une liste de voitures sur une table, vous devez vous assurer qu'il y a une valeur unique (aucun double) du nombre de balise pour chaque voiture car chaque voiture devrait en avoir un et doit avoir un numéro de balise. Cela garantit qu'il n'existe pas d'enregistrement en double sur la table.
2. Une table (A) qui contient des informations devrait rendre ces informations disponibles aux autres tables (telle que B)
3. Deux tables ne doivent pas servir le même but. Une fois que vous avez des informations uniques sur chaque table, une table peut rendre ses données disponibles à d'autres tables qui en ont besoin afin que les mêmes informations ne figurent pas dans plusieurs tables

Ces problèmes sont résolus en spécifiant une colonne particulière comme la «clé» de la table. Une telle colonne est appelée la clé primaire.

Dans une base de données relationnelles, qui est le cas pour la plupart des bases de données que vous allez créer, chaque table doit avoir au moins une clé primaire. Par exemple, une clé primaire sur un compte table d'une base de données de la Banque peut être définie sur un champ de compte bancaire parce que chaque client doit avoir un numéro de compte bancaire unique. Une table peut également utiliser plusieurs colonnes pour représenter la clé primaire si vous le jugez nécessaire.

Une fois que vous avez décidé d'avoir une clé primaire dans une table, vous devez décider quel type de données ce champ contiendra. Si vous créez une table qui peut utiliser un champ connu et évident comme unique, un exemple serait le numéro de l'emplacement d'une bibliothèque, vous pouvez définir son type de données char ou varchar et rendre une clé primaire. Dans de nombreux autres cas, par exemple, si vous ne pouvez pas décider sur un champ particulier contenant des informations uniques, un exemple serait le nom du client du contact, vous devez créer votre propre champ unique et rendre la clé primaire. Ce champ doit avoir un type de données int.

1. Démarrez Microsoft SQL Server et connectez-vous au serveur
2. Cliquez avec le bouton droit de la souris sur le nom du serveur, puis cliquez sur Nouvelle requête
3. Pour démarrer une nouvelle base de données, tapez le code suivant :
   

   --=============================================
   --Database :     YugoNationalBank
   --Author :       FunctionX
   --Date Created : Monday 09 april 2007
   --============================================= 
   USE master
   GO 
    
    
   --Drop the database if it already exists 
   IF EXISTS (SELECT name 
              FROM sys.databases 
              WHERE name = N'YugoNationalBank'
   ) 
   DROP DATABASE YugoNationalBank 
   GO 
    
    
   CREATE DATABASE YugoNationalBank 
   GO

Pour créer une clé primaire dans SQL Server Management Studio, créez une colonne et spécifiez son type de données :

• Puis, dans la barre d'outils, cliquez sur le bouton Set Primary Key
• Vous pouvez également cliquer avec le bouton droit de la souris sur une colonne et cliquez sur Set Primary Key

Voici un exemple :

Pour créer une colonne principale à l'aide de SQL, la première chose à faire est, sur le côté droit de la définition de la colonne, tapez PRIMARY KEY. Voici un exemple :

CREATE TABLE Persons 
(
    PersonID int identity(1,1) PRIMARY KEY NOT NULL, 
    FirstName nvarchar (20), 
    LastName nvarchar (20) NOT NULL) ;

Dans le SQL, vous pouvez donner un nom spécifique à une clé primaire. Pour ce faire, vous pouvez d'abord créer la colonne. Ensuite, quelque part avant la parenthèse fermante de la table, indiquez la colonne de clé primaire à l'aide de la formule suivante :

CONSTRAINT PrimaryKeyName PRIMARY KEY (ColumnName)

Dans cette formule, le mot-clé CONSTRAINT et l'expression PRIMARY KEY (sensible à la casse) sont requis. Dans l'espace réservé au PrimaryKeyName, entrez le nom que vous souhaitez donner à la clé primaire. Entre les parenthèses de l'expression PRIMARY KEY, entrez le nom de la colonne qui sera utilisé comme clé primaire. Voici un exemple :

CREATE TABLE Persons 
(
     PersonID int identity(1,1) NOT NULL, 
     FirstName nvarchar (20) 
     LastName nvarchar (20) NOT NULL 
     CONSTRAINT PrimKeyPeople PRIMARY KEY(PersonID)
) ;

Par convention ou par tradition, le nom principal commence par PK_, suivi du nom de la table. Voici un exemple :

USE Exercise2 ; 
GO 
 
 
CREATE TABLE Persons 
(
    PersonID int identity(1,1) NOT NULL, 
    FirstName nvarchar (20), 
    LastName nvarchar (20) NOT NULL,
    CONSTRAINT PK_Persons PRIMARY KEY(PersonID) 
); 
GO

En poursuivant avec notre base de données de Banque, imaginez qu'un client vient à la Banque pour déposer de l'argent. Nous avons déjà établi qu'il serait redondant de créer un nouveau compte chaque fois que le client vient pour effectuer une transaction. Au lieu de cela, vous obtiendrez les informations relatives au compte du client, fournissez ces informations à la table utilisée pour traiter les transactions. Comme nous avons décrit précédemment, la table du compte doit être capable de fournir ses données aux autres tables qui auraient besoin de ces données. Pour rendre ce flux d'informations possible d'une table à l'autre, vous devez créer une relation entre elles.

Pour le rendre possible pour une table B à recevoir des données d'un tableau A, le tableau B doit avoir une colonne qui représente la table A. Cette colonne agit comme un "Ambassadeur" ou un lien. Comme un pseudo-ambassadeur, la colonne dans la table B n'appartient presque pas à cette table : il permet principalement aux deux tables de communiquer. Pour cette raison, la colonne dans la table B est appelée une clé étrangère.

Une clé étrangère est une colonne d'une table dont les données proviennent d'une autre table.

Pour créer une clé étrangère dans la fenêtre de création de table, dans la table qui recevra la clé, il vous suffit de créer une colonne avec les règles suivantes :

• La colonne doit avoir le même nom que la colonne primaire de la table qu'elle représente (mais ce n'est pas une exigence)
• La colonne doit (ceci est requis) avoir le même type de données que la colonne primaire de la table qu'elle représente

Voici un exemple d'une colonne nommée GenderID, qui est une clé étrangère :

De toute évidence afin de disposer d'informations découlant d'une table à l'autre, la table qui conserve les informations principales doit être créée.Vous pouvez la créer avant ou après la création de l'autre table, tant que vous n'avez pas établi un lien entre les deux tables, peu importe quelle séquence vous utilisez pour les créer.

La table qui contient une clé primaire et celle qui contient les informations qui utiliseraient une autre table est appelée table primaire ou table parente. La table qui recevra les informations de l'autre table est appelée la table étrangère ou la table enfant.

Pour créer une clé étrangère dans une table :

1. A partir de l'Explorateur d'objets, ouvrez la table enfant en mode Design
2. Cliquez avec le bouton droit de la souris n'importe où dans le tableau et cliquez sur relations...
   
   
3. Dans la boîte de dialogue Foreign Key Relationships, cliquez sur Ajouter
4. Un nom par défaut pourrait être proposé pour vous. Vous pouvez l'accepter ou le modifier. Pour modifier le nom de la clé étrangère, dans la partie droite, développez l'identité et modifiez la chaîne dans le champ (le Nom) :
   
   
5. Si nécessaire, de la même façon, vous pouvez créer d'autres clés étrangères en cliquant sur Ajouter. Pour supprimer une clé étrangère existante, sélectionnez d'abord sous le cadre Selected Relationships et cliquez sur Supprimer.
   Une fois que vous êtes prêt, cliquez sur Fermer

Vous pouvez également créer une clé étrangère dans le SQL. La formule de base à utiliser est :

FOREIGN KEY REFERENCES ParentTableName (ForeignKeyCcolumn) 

L'expression FOREIGN KEY et le mot-clé REFERENCES sont requis. Dans l'espace réservé pour ParentTableName, entrez le nom de la table primaire qui détient l'information qui sera consultée dans la table en cours. Entre les parenthèses de ParentTableName, entrez le nom de la colonne primaire de la table parente. Voici un exemple :

CREATE TABLE Persons 
(
    PersonID int identity(1,1) PRIMARY KEY NOT NULL, 
    FirstName nvarchar (20), 
    LastName nvarchar (20) NOT NULL, i
    GenderID int NULL FOREIGN KEY REFERENCES Genders(GenderID)
) ;

Notez que la clé étrangère n'a pas de nom d'objet comme nous l'avons vu pour la clé primaire. Si vous ne spécifiez pas le nom de la clé étrangère, l'interprète SQL créerait automatiquement pour vous un nom par défaut. Sinon, pour créer un nom, après la création de la colonne, entrez le mot-clé CONSTRAINT suivi du nom de votre choix et poursuivez le reste, comme nous l'avons vu plus haut. Exemple :

CREATE TABLE Persons 
(
    PersonID int identity(1,1) PRIMARY KEY NOT NULL, 
    FirstName nvarchar (20), 
    LastName nvarchar (20) NOT NULL, 
    GenderID NULL CONSTRAINT FKGenders 
    FOREIGN KEY REFERENCES Genders (GenderID) 
);

Comme nous l'avons déjà mentionné, une base de données relationnelle est celle dans laquelle les informations circulent d'une table à l'autre. Pour préparer les tables à cela, vous créez les clés primaires et étrangères, comme nous avons fait jusqu'ici. Une fois que les tables sont prêtes, vous pouvez les relier, ce qui est appelé à la création d'une relation entre deux tables.

Si vous n'avez pas créé une clé étrangère avec le code SQL, vous pouvez la créer lors de l'établissement d'une relation entre deux tables.

Pour créer une relation entre deux tables

1. Ouvrez la table enfant dans la vue de conception
2. Cliquez avec le bouton droit de la souris (n'importe où dans la table) et cliquez sur Relationships...
   Si la clé étrangère (nécessaire) n'existe pas, cliquez sur Ajouter, puis indiquez son nom sous l'identité dans la partie droite.
3. Dans le cadre de relations sélectionnées, cliquez sur la clé étrangère qui contiendra la relation
4. Dans la partie droite, développez la spécification de tables et de colonnes
5. Cliquez sur son bouton de sélection
6. Dans la zone de liste déroulante de Table de Clé Primaire, sélectionnez la Table Parente qui contient les données primaires
7. Sous la Table Parente, cliquez et sélectionnez sa colonne de Clé Primaire
8. Sous la table de Clé Etrangère, assurez-vous que le nom de la table en cours est défini.
   Sous le nom de la Table Enfant, cliquez et sélectionnez le nom de la colonne Clé Etrangère. Voici un exemple :
   
   
9. Cliquez sur OK.
   Lorsqu'une relation a été créée, elle serait affichée dans les tables et section de spécification de colonne :
   
   
10. De la même façon, vous pouvez créer d'autres relations en cliquant sur Ajouter et en configurant le lien.
    Une fois que vous avez terminé, cliquez sur Fermer

1. Pour terminer notre base de données avec ses tables, leurs clés primaires, leurs clés étrangères et certaines données dans les tables, modifiez le code dans la fenêtre de requête comme suit :
   

   -- ============================================= 
   -- Database:        YugoNationalBank  
   -- Author:          FunctionX  
   -- Date Created:    Monday 09 April 2007  
   -- =============================================  
   USE master  
   GO    
    
    
   -- Drop the database if it already exists  
   IF  EXISTS (  
   SELECT name   	
        	FROM sys.databases   
     		WHERE name = N'YugoNationalBank'  
    
    
   )  
   DROP DATABASE YugoNationalBank  
   GO    
   CREATE DATABASE YugoNationalBank  
   GO 
    -- ========================================= 
    -- Database: YugoNationalBank  
   -- Table:    Locations 
    -- =========================================  
   USE YugoNationalBank  
   GO    
    
    
   IF OBJECT_ID(N'dbo.Locations', N'U') IS NOT NULL 
   DROP TABLE dbo.Locations  
   GO    
    
    
   CREATE TABLE Locations 
   (      
        LocationID int Identity(1,1) NOT NULL,      
        LocationCode nvarchar(10) NOT NULL,    
        Address nvarchar(120),    
        City nvarchar(50),    
        State nvarchar(50),  
        Notes text NULL,   
        CONSTRAINT PK_Locations PRIMARY KEY (LocationID) 
   );  
   GO  
   -- ========================================= 
   -- Database: YugoNationalBank  
   -- Table:    AccountTypes 
   -- =========================================  
   USE YugoNationalBank  
   GO    
    
    
   IF OBJECT_ID(N'dbo.AccountTypes', N'U') IS NOT NULL    
     DROP TABLE dbo.AccountTypes  
   GO
    
    
   CREATE TABLE AccountTypes  
   (      
       AccountTypeID int Identity(1,1) NOT NULL,       
       AccountType nvarchar(40) NOT NULL,       
       Notes text NULL,       
       CONSTRAINT PK_AccountTypes PRIMARY KEY (AccountTypeID)  
   );  
   GO    
   -- =========================================  
   -- Database: YugoNationalBank  
   -- Table:    Employees  
   -- =========================================  
   IF OBJECT_ID(N'dbo.Employees', N'U') IS NOT NULL    
    DROP TABLE dbo.Employees  
   GO  
   CREATE TABLE Employees  
   (      
       EmployeeID int identity(1,1) NOT NULL,       
       EmployeeNumber char(6),      
       FirstName nvarchar(32),      
       LastName nvarchar(32) NOT NULL,      
       Title nvarchar(50),      
       CanCreateNewAccount bit,      
       HourlySalary smallmoney,      
       EmailAddress nvarchar(100),      
       Username nvarchar(20),     
       Password nvarchar(20),     
       Notes text,      
       CONSTRAINT PK_Employees PRIMARY KEY (EmployeeID) 
    );  
   GO    
    
   -- =========================================  
   -- Database: YugoNationalBank  
   -- Table:    Customers  
   -- =========================================  
   IF OBJECT_ID(N'dbo.Customers', N'U') IS NOT NULL    
    DROP TABLE dbo.Customers  
   GO  
   CREATE TABLE Customers  
   (      
       CustomerID int Identity(1,1) NOT NULL,      
       DateCreated date,      
       AccountNumber nvarchar(20),      
       AccountTypeID int Constraint FK_TypeOfAccount   	
       References AccountTypes(AccountTypeID),     
       CustomerName nvarchar(50) NOT NULL,      
       DateUpdated date,     
       Notes text,      
       CONSTRAINT PK_Customers PRIMARY KEY (CustomerID) 
   );  
   GO    
    
   -- =========================================  
   -- Database: YugoNationalBank  
   -- Table:    ChargeReasons 
   -- =========================================  
   IF OBJECT_ID(N'dbo.ChargeReasons', N'U') IS NOT NULL   
   DROP TABLE dbo.ChargeReasons  
   GO  
   -- =========================================  
   -- Database: YugoNationalBank  
   -- Table:    Deposits  
   -- =========================================  
   IF OBJECT_ID(N'dbo.Deposits', N'U') IS NOT NULL    
     DROP TABLE dbo.Deposits  
   GO    
    
   CREATE TABLE Deposits  
   (      
       DepositID int identity(1, 1) NOT NULL,      
       LocationID int Constraint FK_DepositLocation  		
       References Locations(LocationID) NOT NULL,     
       EmployeeID int Constraint FK_Clerk   		
       References Employees(EmployeeID),      
       CustomerID int Constraint FK_Depositor   		
       References Customers(CustomerID) NOT NULL,      
       DepositDate date NOT NULL,      
       DepositAmount smallmoney NOT NULL,      
       Notes text,       
       CONSTRAINT PK_Deposits PRIMARY KEY (DepositID)  
   );  
   GO    
    
   -- =========================================  
   -- Database: YugoNationalBank  
   -- Table:    Withdrawals  
   -- =========================================  
   IF OBJECT_ID(N'dbo.Withdrawals', N'U') IS NOT NULL    
    DROP TABLE dbo.Withdrawals  
   GO    
    
   CREATE TABLE Withdrawals  
   (      
    
       WithdrawalID int identity(1, 1) NOT NULL,      
       LocationID int Constraint FK_WithdrawlLocation   	
       References Locations(LocationID) NOT NULL,     
       EmployeeID int Constraint FK_ProcessedBy   		
       References Employees(EmployeeID),      
       CustomerID int Constraint FK_CustomerAccount   	
       References Customers(CustomerID) NOT NULL,     
       WithdrawalDate date NOT NULL,     
       WithdrawalAmount smallmoney NOT NULL,      
       WithdrawalSuccessful bit NOT NULL,      
       Notes text,       
       CONSTRAINT PK_Withdrawas PRIMARY KEY (WithdrawalID)  
   );    
    
   -- =========================================  
   -- Database: YugoNationalBank  
   -- Table:    CheckCashing  
   -- =========================================  
   IF OBJECT_ID(N'dbo.CheckCashing', N'U') IS NOT NULL    
    DROP TABLE dbo.CheckCashing  
   GO    
    
   CREATE TABLE CheckCashing  
   (      
       CheckCashingID int identity(1, 1) NOT NULL,     
       LocationID int Constraint FK_BranchLocations   	
       References Locations(LocationID) NOT NULL,     
       EmployeeID int Constraint FK_Employees   	
       References Employees(EmployeeID),     
       CustomerID int Constraint FK_Customers   	
       References Customers(CustomerID) NOT NULL,     
       CheckCashingDate date NOT NULL,   
       CheckCashingAmount smallmoney NOT NULL,    
       CheckCashingSuccessful bit NOT NULL,      
       Notes text,       
       CONSTRAINT PK_CheckCashing PRIMARY KEY(CheckCashingID) 
   );  
   GO

2. Appuyez sur F5 pour exécuter l'instruction.

Un schéma est une fenêtre qui affiche visuellement les relations entre les tables d'une base de données. Pour créer un diagramme :

1. Dans l'Explorateur d'objets, dans le nœud de base de données, vous pouvez cliquer sur la base de données diagrammes
2. Une boîte de dialogue vous informe que cette base de données ne dispose pas d'un diagramme. Lisez le message et cliquez sur Oui
3. Cliquez avec le bouton droit de la souris sur les schémas de base de données, puis cliquez sur Nouveau schéma de base de données
4. Dans la boîte de dialogue Ajouter une table, cliquez sur chaque table et cliquez sur Ajouter.
   Alternativement, vous pouvez double-cliquer sur une table pour l'ajouter
5. Dans la boîte de dialogue Ajouter une table, vous pouvez cliquer sur Fermer.
   Dans la barre d'outils, vous pouvez cliquer sur le bouton Zoom et sélectionnez une valeur plus grande ou plus petite.
   Pour déplacer une table, vous pouvez faire glisser sa barre de titre. Voici un exemple :
   
   
6. Pour établir une relation, vous pouvez cliquer sur la zone grise à gauche de la colonne de la table parente et la déposer sur n'importe quelle colonne dans la Table Enfant. La meilleure façon est de cliquer sur la zone grise de la colonne Clé Primaire de la Ttable Parent, faites glisser cette zone puis déposez-la sur la colonne Clé Etrangère de la Table Enfant. Voici un exemple :
   
   
7. Une boîte de dialogue Tables et Colonnes s'ouvrirait. Elle afficherait la colonne qui a été glissée et la colonne sur laquelle vous êtes tombé.
   Si vous aviez sélectionné simplement n'importe quelle colonne, elle afficherait mais ce n'est peut-être pas celle que vous vouliez faire glisser ; autrement dit, elle peut ne pas être la colonne réelle qui est censée gérer la relation.
   Quoi qu'il en soit, sous le titre de la Table de Clé Primaire, vous devez sélectionner la Table Parente
8. Sous la Table Parente, sélectionnez sa Colonne Primaire
9. Sous Table Etrangère, sélectionnez la colonne de Clé Etrangère. Voici un exemple :
   
   
10. Une fois que vous êtes prêt, cliquez sur OK. Un lien serait créé entre les tables
    
    
11. De la même façon, vous pouvez créer d'autres relations.
    Lorsque vous avez terminé, vous pouvez enregistrer et fermer la base de données.

1. Dans l'Explorateur d'objets, dans le nœud YugoNationalBank, cliquez sur une base de données Diagrammes
2. Une boîte de dialogue vous informe que cette base de données ne dispose pas d'un diagramme :
   
   
   
   Lisez le message et cliquez sur Oui
3. Cliquez avec le bouton droit de la souris sur les schémas de base de données, puis cliquez sur Nouveau Schéma de base de données
4. Dans la boîte de dialogue Add Tble, cliquez sur Customers, puis cliquez sur le bouton Add
5. Double-cliquez sur CheckCashing pour l'ajouter
6. De la même manière, ajoutez les tables AccountTypes, Deposits, Employees, Locations et Withdrawals Tables
7. Dans la boîte de dialogue Add Table, cliquez sur Fermer.
   Notez que, selon comment nous avons créé la base de données et ses objets, les relations ont déjà été créées :
   
   
8. Pour enregistrer le schéma, dans la barre d'outils standard, cliquez sur Enregistrer
9. Définissez son nom à dgmYugoNationalBank puis cliquez sur le bouton OK.
10. Fermez la fenêtre

Sur une base de données typiques, les informations vont et viennent. Pour une banque, les comptes des clients sont créés et supprimés sur une base régulière. Lorsqu'un compte est supprimé, il y a des préoccupations concernant les transactions liées à ce compte. L'intégrité référentielle vous permet de gérer ces aspects d'une base de données. Vous devez vous assurer que lorsque les données sont supprimées d'une Table Parent, les tables Enfant sont notifiées et leurs enregistrements liés sont également supprimés. Lorsque l'information est modifiée sur une Table Parent, les informations associées sont modifiées dans les tables de pensions alimentaires pour enfants.

Pour gérer l'intégrité référentielle, vous utilisez la boîte de dialogue Relations de Clé Etrangère. Vous pouvez y accéder depuis la vue de conception d'une table ou à partir de la fenêtre de diagramme.

1. Dans l'Explorateur d'objets, développez le nœud tables sous YugoNationalBank.
   Cliquez avec le bouton droit de la souris sur dbo.Customers, puis cliquez sur Créer
2. Cliquez avec le bouton droit de la souris dans la table et cliquez sur relations
3. Dans le cadre de relations sélectionnées, cliquez sur FK_CustomerAccount. Dans la section de droite, développez INSERT et UPDATE Specification
4. Cliquez sur Supprimer la règle. Dans sa zone de liste déroulante, sélectionnez Cascade
5. Cliquez sur une règle de mise à jour. Dans sa zone de liste déroulante, sélectionnez Cascade :
   
   
6. De la même manière, spécifiez les options suivantes
   

   Clé étrangère	Supprimer la règle	Mise à jour de la règle
   FK_ChargeReasons	Cascade	Cascade
   FK_Customers	Cascade	Cascade
   FK_Depositor	Cascade	Cascade
   FK_TypeOfAccount	Cascade	Cascade

7. Cliquez sur Fermer
8. Enregistrez et fermez la table
9. De la même manière, ouvrez la table Deposits dans le mode design
10. Accédez à sa boîte de dialogue Relationships
11. Accédez aux propriétés de son champ FK_Clerk.
    Spécifiez son Supprimer la Règle et sa Mise à Jour de la Règle, les deux à cascade
12. Effectuez les mêmes actions pour les autres relations
13. Fermez la boîte de dialogue Relations
14. Enregistrez et fermez la table

Lors de l'exécution d'entrée de données, dans certaines colonnes, même après avoir indiqué les types des valeurs que vous attendez de l'utilisateur de fournir pour certains une colonne, vous pouvez restreindre une plage de valeurs autorisées. De la même façon, vous pouvez créer une règle qui doit être respectée sur une combinaison de colonnes avant la création de l'enregistrement. Par exemple, vous pouvez demander au moteur de base de données de vérifier qu'au moins l'une des deux colonnes a reçu une valeur. Par exemple, sur une table qui conserve des informations sur les clients, vous pouvez demander au moteur de base de données de vérifier que, pour chaque enregistrement, soit le numéro de téléphone ou l'adresse e-mail du client est entré.

La possibilité de vérifier qu'une ou plusieurs règles sont respectées sur une table est appelée une Check Constraint. Une Check Constraint est une opération booléenne effectuée par l'interprète SQL. L'interprète examine une valeur qui a simplement été fournie pour une colonne. Si la valeur est appropriée :

1. La contrainte produit TRUE
2. La valeur est acceptée.
3. La valeur est affectée à la colonne

Si la valeur n'est pas appropriée :

1. La contrainte produit FALSE
2. La valeur oest rejetée.
3. La valeur n'est pas affectée à la colonne

Vous créez une contrainte check au moment où vous créez une table.

Pour créer une contrainte check, lors de la création d'une table, cliquez avec le bouton droit de la souris n'importe où (même à l'extérieur) dans la table et cliquez sur CHECK Constraints...

Ce serait ouvrir la boîte de dialogue Check Constraints. A partir de cette fenêtre, vous pouvez cliquer sur Ajouter. Une contrainte étant un objet, vous devez fournir un nom pour elle. L'élément le plus important d'information qui devrait contenir une contrainte check est le mécanisme qu'il utiliserait pour vérifier ses valeurs. Ceci est prévu comme une expression. Par conséquent, pour créer une contrainte, vous pouvez cliquer sur expression et cliquez sur son bouton de sélection. Ce serait ouvrir la boîte de dialogue Check Constraint Expression.

Pour créer l'expression, tapez tout d'abord le nom de la colonne sur laquelle la contrainte s'appliquera, suivi de parenthèses. Entre les parenthèses, utilisez l'arithmétique et/ou des opérateurs SQL que nous avons déjà étudiés. Voici un exemple qui vérifiera qu'une nouvelle valeur spécifiée pour le numéro d'étudiant est supérieure à 1000 :

Après la création de l'expression, vous pouvez cliquer sur OK. Si l'expression n'est pas valide, vous recevriez un message d'erreur et la possibilité de la corriger.

Vous pouvez créer autant de contraintes de vérification que vous jugez nécessaire pour votre table :

Après avoir créé les check contraints, vous pouvez cliquer sur OK.

Pour créer une contrainte check dans SQL, créez tout d'abord la colonne sur laquelle s'appliquera la contrainte. Avant la parenthèse fermante de la définition de la table, utilisez la formule suivante :

CONSTRAINT name CHECK (expression) 

Le CONSTRAINT et les mots-clés CHECK sont requis. Sous la forme d'un objet, assurez-vous de que vous fournissez un nom pour lui. A l'intérieur des parenthèses qui suivent l'opérateur CHECK, entrez l'expression qui est appliquée. Voici un exemple qui veillera à ce que le salaire horaire spécifié pour un employé soit supérieur à 12,50 :

CREATE TABLE Employees 
(
    [Employee Number] nchar (7)
    [Full Name] varchar (80), 
    [Hourly Salary] smallmoney, 
    CONSTRAINT CK_HourlySalary CHECK ([Hourly Salary] > 12,50) 
);

Il est important de comprendre qu'une contrainte check n'est ni une expression ni une fonction. Une contrainte check contient une expression et peut contenir une fonction comme faisant partie de sa définition.

Après la création de (s) la constraint (s) pour une table, dans l'Explorateur d'Objet de Microsoft SQL Server Management Studio, à l'intérieur du nœud de la table, il y a un nœud nommé Contraints et, si vous le développez, vous verriez le nom de la contrainte.

Avec la (les) constrainte (s) en place, au cours de la saisie de données, si l'utilisateur (ou votre code) fournit une valeur non valide, une erreur afficherait. Voici un exemple :

Au lieu d'une expression qui utilise uniquement les opérateurs réguliers, vous pouvez utiliser une fonction pour aider dans le processus de vérification. Vous pouvez créer et utiliser votre propre fonction ou vous pouvez utiliser l'une des fonctions Transact-SQL intégrées.

1. Dans l'Explorateur d'objets, cliquez avec le bouton droit de la souris sur le nom du serveur, puis cliquez sur Start PowerShell
2. Dans la fenêtre PowerShell, tapez SQLCMD et appuyez sur la touche Entrée
3. Pour créer une base de données et une nouvelle table qui dispose d'un mécanisme de vérification, tapez ce qui suit :
   

   CREATE DATABASE GreensvilleElectricCompany ; GO CREATE TABLE Customers ( AccountNumber nchar(14) primary key not null, CustomerName nvarchar (50) NOT NULL, PhoneNumber nchar(16), EmailAddress nvarchar(50), CONSTRAINT CK_CustomerContact CHECK ((PhoneNumber IS NOT NULL) OR (EmailAddress IS NOT NULL)) ); GO

   
   
4. Pour ajouter des enregistrements à la nouvelle table, tapez ce qui suit :
   

   INSERT INTO Customers 
   VALUES(N'188395805',N'Ann Zeke',N'301-128-3506',N'azeke@yahoo.jp'), 
         (N'806200422', N'Joan Simms',N'410-114-6820',N'jsimmson@emailct.com'), 
         (N'402628475' N'Peter Dorka, N' (202)050-1629',N'pdorka@hotmail.com'), 
         (N'666204275' N'James Bengbiss',N'443-158-1833',N'jbango@emailct.com'); 
   GO

5. Pour essayer d'ajouter un nouvel enregistrement à la table, tapez ce qui suit :
   

   1 > INSERT INTO Customers 
   2 > VALUES(N'402628475',N'James Darfield',N'202-188-8742',N''); 
   3 > GO

6. Notez que vous recevez un message d'erreur :
   

   MSG 2627, Level 14, State 1, Server CENTRAL, Line 1 
   Violation of PRIMARY KEY Constraint 'PK__Customer__BE2ACD6E51BA1E3A'. Cannot ins 
   ert duplicate key in object 'dbo.Customers'.
   The statement has been terminated.
   1 >
    
   

7. Pour supprimer la base de données, tapez :
   

   DROP DATABASE GreensvilleElectricCompany ; 
   GO
   

8. Tapez exit, puis appuyez sur entrée
9. Pour fermer la fenêtre PowerShell, tapez exit, puis appuyez sur la touche Entrée