Contraintes en SQL

Objectif et types de contraintes en SQL

SQL dispose d'un éventail de types de contraintes qui servent à des fins différentes pour maintenir l'intégrité de la base de données. Ces contraintes peuvent être classées comme suit :

• Contrainte de clé primaire
• Contrainte de clé étrangère
• Contrainte d'unicité
• Contrainte de vérification
• Contrainte de non nullité
• Contrainte par défaut

Contraintes de clé primaire, de clé étrangère et d'unicité

Approfondissons les trois premiers types de contraintes : 1. Contrainte de clé primaire :Chaque ligne d'une table doit avoir un identifiant unique, appelé clé primaire. C'est une contrainte qui garantit l'unicité de chaque ligne en n'autorisant pas les valeurs en double ou les valeurs NULL pour la ou les colonnes spécifiées.2. Contrainte de clé étrangère :Une clé étrangère est utilisée pour relier deux tables en se référant à la clé primaire d'une autre table. Cette contrainte garantit que les données saisies dans la ou les colonnes de la clé étrangère doivent correspondre aux valeurs de la clé primaire référencée, ce qui permet de maintenir la cohérence et l'intégrité des données entre les tables.3. Contrainte d'unicité :Semblable à une clé primaire, la contrainte d'unicité garantit également que les données saisies dans une colonne ou un groupe de colonnes spécifié sont uniques. Cependant, contrairement aux clés primaires, la contrainte d'unicité autorise les valeurs NULL.

Contrainte de vérification en SQL

Une contrainte de vérification est une règle qui permet de contrôler les données insérées dans une ou plusieurs colonnes spécifiées, en fonction d'une condition booléenne. Si la condition se vérifie, les données sont acceptées ; dans le cas contraire, elles sont rejetées.

Contraintes non nulles et par défaut

1. Contrainte non nulle : Cette contrainte garantit qu'une colonne spécifiée ne peut pas accepter de valeurs NULL. Par défaut, chaque colonne d'une table SQL peut stocker une valeur NULL, mais avec une contrainte Not Null, tu imposes qu'une valeur soit fournie pour la colonne.2. Contrainte par défaut :Une contrainte par défaut permet de définir une valeur par défaut pour une colonne au cas où une valeur ne serait pas fournie lors de l'insertion d'un nouvel enregistrement. Cette valeur prédéfinie est automatiquement utilisée par SQL si aucune donnée n'est fournie pour cette colonne.En conclusion, il est essentiel de comprendre l'objectif et les types de contraintes en SQL pour maintenir l'intégrité et la cohérence des données dans l'ensemble de la base de données. Se familiariser avec la fonction de chaque contrainte permet de créer des bases de données avec des données précises et fiables.

Implémentation et modification des contraintes en SQL

En SQL, les contraintes jouent un rôle essentiel pour assurer l'intégrité et la cohérence des données dans l'ensemble de la base de données. L'ajout, la modification et la suppression de contraintes est un aspect crucial de la gestion des bases de données au fur et à mesure que les données augmentent et que les exigences du schéma changent. Dans cette section, tu apprendras à procéder étape par étape pour ajouter, modifier et supprimer des contraintes.

Ajouter une contrainte en SQL

Pour ajouter une contrainte, tu peux soit la spécifier lors de la création d'une table, soit utiliser l'instruction `ALTER TABLE` pour l'ajouter à une table existante. Voici des exemples d'ajout de différents types de contraintes :

1. Contrainte de clé primaire : Création de la contrainte lors de la création de la table :

CREATE TABLE Employee ( EmployeeID INT PRIMARY KEY, FirstName VARCHAR(255) NOT NULL, LastName VARCHAR(255) NOT NULL, EmailAddress VARCHAR(255) UNIQUE ) ;

2. Contrainte de clé étrangère : Ajout d'une contrainte à une table existante :

ALTER TABLE Employee ADD FOREIGN KEY (DepartmentID) REFERENCES Department(DepartmentID) ;

3. Contrainte unique : Spécification de la contrainte lors de la création d'une table :

CREATE TABLE Employee ( EmployeeID INT PRIMARY KEY, FirstName VARCHAR(255) NOT NULL, LastName VARCHAR(255) NOT NULL, EmailAddress VARCHAR(255) UNIQUE ) ;

4. Vérifier la contrainte : Ajout d'une contrainte à une table existante :

ALTER TABLE Student ADD CHECK (Grade >= 0 AND Grade <= 100) ;

5. Contrainte non nulle : Spécification de la contrainte lors de la création d'une table :

CREATE TABLE Employee ( EmployeeID INT PRIMARY KEY, FirstName VARCHAR(255) NOT NULL, LastName VARCHAR(255) NOT NULL, EmailAddress VARCHAR(255) UNIQUE ) ;

6. Contrainte par défaut : Ajout d'une contrainte à une table existante :

ALTER TABLE Employee ADD DEFAULT 0 FOR NumberOfLogins ;

Modification des contraintes en SQL

SQL propose plusieurs façons de modifier les contraintes, comme la modification d'une contrainte ou l'abandon d'une contrainte et sa recréation avec de nouvelles exigences. Pour modifier des contraintes existantes, tu utiliseras souvent l'instruction `ALTER TABLE` et tu choisiras parmi différentes options, comme la modification des propriétés de la contrainte ou la définition d'une nouvelle contrainte avec une portée différente.

Modification des contraintes en SQL

Une fois qu'une contrainte a été appliquée à une table, tu peux avoir besoin de la modifier. SQL te permet de modifier certains types de contraintes, en particulier la contrainte par défaut et la contrainte de vérification. Le processus consiste à utiliser l'instruction `ALTER TABLE`, en spécifiant le type de contrainte souhaité et la modification requise. Voici quelques exemples : 1. Modification d'une contrainte par défaut : Pour modifier une contrainte par défaut, tu dois d'abord supprimer la contrainte par défaut existante, puis en ajouter une nouvelle avec la valeur par défaut mise à jour. Par exemple, si tu as initialement défini la valeur par défaut de 'NombreDeLogins' à '0', tu peux la changer en '1' : ALTER TABLE Employee DROP CONSTRAINT DF_Employee_NumberOfLogins ; ALTER TABLE Employee ADD DEFAULT 1 FOR NumberOfLogins ;2. Modification d'une contrainte de contrôle : Pour modifier une contrainte de contrôle, tu dois d'abord supprimer la contrainte de contrôle existante, puis en créer une nouvelle avec les conditions mises à jour. Par exemple, si tu as initialement limité les notes des étudiants à une fourchette comprise entre 0 et 100, tu peux l'étendre jusqu'à 110 : ALTER TABLE Student DROP CONSTRAINT CK_Student_GradeRange ; ALTER TABLE Student ADD CONSTRAINT CK_Student_GradeRange CHECK (Grade >= 0 AND Grade <= 110) ;

Suppression d'une contrainte en SQL

Pour supprimer entièrement une contrainte de la table, tu peux utiliser l'instruction `ALTER TABLE` avec la clause `DROP CONSTRAINT`. Voici quelques exemples :

1. Suppression d'une contrainte de clé primaire :

ALTER TABLE Employee DROP CONSTRAINT PK_Employee ;

2. Suppression d'une contrainte de clé étrangère :

ALTER TABLE Employee DROP CONSTRAINT FK_Employee_DepartmentID ;

3. Suppression d'une contrainte d'unicité :

ALTER TABLE Employee DROP CONSTRAINT UQ_Employee_EmailAddress ;

4. Suppression d'une contrainte de vérification :

ALTER TABLE Student DROP CONSTRAINT CK_Student_GradeRange ;

5. Abandon d'une contrainte non nulle : Pour supprimer une contrainte non nulle, tu dois modifier la définition de la colonne et autoriser les valeurs NULL :

ALTER TABLE Employee ALTER COLUMN FirstName NULL ;La connaissance de la mise en œuvre et de la modification des contraintes en SQL est essentielle pour maintenir l'intégrité et la cohérence des données dans ta base de données. Garde ces techniques dans ton arsenal pour adapter les contraintes de ta base de données aux différentes exigences en matière de données et pour optimiser les performances de ta base de données.

Les contraintes en SQL expliquées : Exemples pratiques

Lorsque tu travailles avec des bases de données relationnelles, il est essentiel de garantir l'exactitude et l'intégrité des données de tes tables. Les contraintes SQL aident à maintenir ces normes en appliquant des règles et des conditions aux données insérées dans les tables. Dans cette section, tu vas explorer des exemples pratiques de différents types de contraintes SQL, notamment les contraintes de vérification, les contraintes uniques, les clés primaires et les clés étrangères.

Exemples de contraintes de contrôle en SQL

Une contrainte de contrôle te permet d'imposer une condition spécifique à une colonne de table pour t'assurer que seules des données valides sont stockées dans cette colonne. En d'autres termes, une contrainte de contrôle limite la plage des valeurs qui peuvent être acceptées. Ces exemples pratiques te permettront de mieux comprendre comment utiliser les contraintes de contrôle en SQL :

1. Utilisation d'une contrainte de contrôle pour valider la plage d'âge : Supposons que tu aies une table nommée " Personne " avec une colonne " Âge ", et que tu veuilles t'assurer que l'âge des individus de cette table est compris entre 18 et 110. Tu peux ajouter une contrainte de vérification à la colonne 'Âge' comme suit :

CREATE TABLE Person ( PersonID INT PRIMARY KEY, FirstName VARCHAR(255) NOT NULL, LastName VARCHAR(255) NOT NULL, Age INT CHECK (Age >= 18 AND Age <= 110) ) ;

2. Utilisation d'une contrainte de vérification pour valider des valeurs numériques : Si tu as une table 'Produit' et que tu veux t'assurer que les prix stockés sont toujours supérieurs à 0, tu peux ajouter une contrainte de contrôle comme suit :

CREATE TABLE Product ( ProductID INT PRIMARY KEY, ProductName VARCHAR(255) NOT NULL, Price DECIMAL(10, 2) CHECK (Price > 0) ) ;Ces exemples montrent comment les contraintes de contrôle peuvent aider à appliquer des règles définies par l'utilisateur sur les données, en garantissant que seules des informations valides sont insérées dans les colonnes.

Exemples de contraintes uniques et de clés primaires

Une contrainte unique garantit que les données d'une colonne ou d'une combinaison de colonnes sont uniques sur toutes les lignes, tandis qu'une clé primaire ajoute une restriction supplémentaire en interdisant les valeurs NULL. Voyons quelques exemples pratiques d'utilisation des contraintes uniques et des clés primaires en SQL : 1. Création d'une contrainte unique et d'une clé primaire sur une seule colonne : CREATE TABLE Customer ( CustomerID INT PRIMARY KEY, EmailAddress VARCHAR(255) UNIQUE NOT NULL, FullName VARCHAR(255) NOT NULL ) ; Dans la table 'Customer', la colonne 'CustomerID' est définie comme clé primaire, tandis que la colonne 'EmailAddress' a une contrainte unique. Les deux assurent l'unicité, mais seule la clé primaire interdit les valeurs NULL. 2. Création d'une contrainte unique composite : CREATE TABLE Song ( SongID INT PRIMARY KEY, Title VARCHAR(255) NOT NULL, Artist VARCHAR(255) NOT NULL, Album VARCHAR(255) NOT NULL, UNIQUE (Title, Artist, Album) ) ; Dans l'exemple ci-dessus, bien que le 'SongID' soit la clé primaire, une contrainte unique composite a été ajoutée à la combinaison des colonnes 'Title', 'Artist' et 'Album'. Cela garantit qu'il n'y a pas deux lignes dans la table "Song" qui ont la même combinaison de titre de chanson, d'artiste et d'album.

Exemples de contraintes de clé étrangère

Les contraintes de clé étrangère sont utilisées pour établir des relations entre les tables. Elles font référence à la clé primaire d'une autre table, ce qui garantit que les données saisies dans la ou les colonnes de la clé étrangère doivent correspondre aux valeurs de la clé primaire référencée. Voici quelques exemples illustrant ce concept : 1. Création d'une contrainte de clé étrangère entre deux tables : CREATE TABLE ProductCategory ( CategoryID INT PRIMARY KEY, CategoryName VARCHAR(255) NOT NULL ) ; CREATE TABLE Product ( ProductID INT PRIMARY KEY, ProductName VARCHAR(255) NOT NULL, CategoryID INT, FOREIGN KEY (CategoryID) REFERENCES ProductCategory(CategoryID) ) ;Dans cet exemple, la table 'Product' possède une colonne 'CategoryID' qui fait référence à la clé primaire 'CategoryID' de la table 'ProductCategory'. Cela permet de s'assurer que chaque produit est associé à une catégorie valide. 2. Ajout d'une contrainte de clé étrangère à une table existante : ALTER TABLE OrderDetails ADD FOREIGN KEY (ProductID) REFERENCES Product(ProductID) ;Dans ce cas, une contrainte de clé étrangère a été ajoutée à la table 'OrderDetails', faisant référence à la clé primaire 'ProductID' de la table 'Product'. Ces exemples démontrent l'importance des contraintes de clés étrangères en SQL. En renforçant l'intégrité référentielle, les contraintes de clé étrangère garantissent que les relations entre les tables sont maintenues et que la base de données reste cohérente et précise.