Langage SQL

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Les contraintes en SQL

Les contraintes sont les règles appliquées aux colonnes de données d'une table. Celles-ci sont utilisées pour limiter le type de données pouvant aller dans une table. Cela garantit l'exactitude et la fiabilité des données de la base de données.

Les contraintes peuvent être au niveau de la colonne ou de la table. Les contraintes de niveau de colonne ne sont appliquées qu'à une seule colonne, alors que les contraintes de niveau de table s'appliquent à l'ensemble de la table.

Les contraintes les plus communes sont :

  •  NOT NULL
  •  DEFAULT
  •  UNIQUE
  •  CHECK
  •  PRIMARY KEY
  •  FOREIGN Key
  •  INDEX

Contrainte NOT NULL

Par défaut, une colonne peut contenir des valeurs NULL. Si vous ne souhaitez pas qu'une colonne ait une valeur NULL, vous devez définir une telle contrainte sur cette colonne en spécifiant que NULL n'est plus autorisé pour cette colonne.

NULL n'est pas la même chose que pas de données, il représente plutôt des données inconnues.

Exemple 1 :

Par exemple, la requête SQL suivante crée une nouvelle table appelée Employes et ajoute quatre colonnes, dont trois sont Id, Nom et Age, nous spécifions pour ne pas accepter les valeurs NULL.

                                CREATE TABLE Employes(
                                    Id INT              NOT NULL,
                                    Nom VARCHAR (20)    NOT NULL,
                                    Age  INT            NOT NULL,
                                    Salaire   DECIMAL (18, 2),       
                                    PRIMARY KEY (Id)
                                );
                            
Exemple 2 :

Si la table Employes a déjà été créée, pour ajouter une contrainte NOT NULL à la colonne Salaire dans MySQL, vous devez écrire une requête comme suit :

                                ALTER TABLE Employes
                                    MODIFY Salaire  DECIMAL (18, 2) NOT NULL;
                            

Contrainte DEFAULT

La contrainte DEFAULT fournit une valeur par défaut à une colonne lorsque l'instruction INSERT INTO ne fournit pas de valeur spécifique.

Exemple 3 :

Par exemple, le code SQL suivant crée la même table Employes, mais ici, la colonne Salaire est définie sur 5000.00 par défaut.

                                CREATE TABLE Employes(
                                    Id INT              NOT NULL,
                                    Nom VARCHAR (20)    NOT NULL,
                                    Age  INT            NOT NULL,
                                    Salaire   DECIMAL (18, 2) DEFAULT 5000.00,       
                                    PRIMARY KEY (Id)
                                );
                            
Exemple 4 :

Si la table Employes a déjà été créée, pour ajouter une contrainte DEFAULT à la colonne Salaire dans MySQL, vous devez écrire une requête comme suit :

                                ALTER TABLE Employes
                                    MODIFY Salaire  DECIMAL (18, 2) DEFAULT 5000.00;
                            

Pour supprimer une contrainte DEFAULT, utilisez la requête suivante :

                                ALTER TABLE Conges
                                    ALTER COLUMN Salaire DROP DEFAULT;
                            

Contrainte UNIQUE

La contrainte UNIQUE empêche que deux enregistrements aient des valeurs identiques dans une colonne.

Exemple 5 :

Par exemple, la requête SQL suivante crée la même table Employes, mais dans ce cas, la colonne Nom est définie sur UNIQUE, de sorte que vous ne pouvez pas avoir deux enregistrements portant le même Nom.

                                CREATE TABLE Employes(
                                    Id INT              NOT NULL,
                                    Nom VARCHAR (20)    NOT NULL UNIQUE,
                                    Age  INT            NOT NULL,
                                    Salaire   DECIMAL (18, 2),       
                                    PRIMARY KEY (Id)
                                );
                            
Exemple 6 :

Si la table Employes a déjà été créée, pour ajouter une contrainte UNIQUE à la colonne Nom dans MySQL, vous devez écrire une requête comme suit :

                                ALTER TABLE Employes
                                    MODIFY Nom VARCHAR(20) NOT NULL UNIQUE;
                            

Contrainte CHECK

La contrainte CHECK active une condition permettant de vérifier la valeur saisie dans un enregistrement. Si la condition est évaluée à false, l'enregistrement viole la contrainte et n'est pas entré dans la table.

Exemple 7 :

Par exemple, la requête SQL suivante crée la même table Employes, mais dans ce cas, la colonne Age est définie sur CHECK, de sorte que vous ne pouvez pas avoir un employe de moins de 18 ans.

                                CREATE TABLE Employes(
                                    Id INT              NOT NULL,
                                    Nom VARCHAR (20)    NOT NULL,
                                    Age  INT            NOT NULL CHECK (Age >= 18),
                                    Salaire   DECIMAL (18, 2),       
                                    PRIMARY KEY (Id)
                                );
                            
Exemple 8 :

Si la table Employes a déjà été créée, pour ajouter une contrainte CHECK à la colonne Age dans MySQL, vous devez écrire une requête comme suit :

                                ALTER TABLE Employes
                                    MODIFY Age INT NOT NULL CHECK (Age >= 18);
                            

Contrainte INDEX

L'INDEX est utilisé pour créer et récupérer des données de la base de données très rapidement. Un index peut être créé en utilisant une seule colonne ou un groupe de colonnes dans une table. Lors de la création de l'index, un ROWID est attribué à chaque ligne avant le tri des données.

Les index appropriés sont bons pour les performances dans les bases de données volumineuses, mais vous devez être prudent lors de la création d'un index. Une sélection de champs dépend de ce que vous utilisez dans vos requêtes SQL.

Vous pouvez créer un index sur une ou plusieurs colonnes en utilisant la syntaxe donnée ci-dessous.

                                CREATE INDEX nom_index
                                    ON nom_table ( colonne1, colonne1, ...);
                            

Pour créer un index sur la colonne Age, afin d'optimiser la recherche d'employés pour un âge spécifique, vous pouvez utiliser la syntaxe suivante :

                                CREATE INDEX idx_age
                                    ON Employes (Age);
                            

Pour supprimer une contrainte INDEX, utilisez la syntaxe SQL suivante.

                                ALTER TABLE Employes
                                    DROP INDEX idx_age;
                            

Contrainte PRIMARY KEY

Une clé primaire est un champ dans une table qui identifie de manière unique chaque ligne/enregistrement dans une table de base de données. Les clés primaires doivent contenir des valeurs uniques. Une colonne de clé primaire ne peut pas avoir de valeur NULL.

Une table ne peut avoir qu'une seule clé primaire, qui peut consister en un ou plusieurs champs. Lorsque plusieurs champs sont utilisés comme clé primaire, ils sont appelés clé composite.

Si une table a une clé primaire définie sur un ou plusieurs champs, vous ne pouvez pas avoir deux enregistrements ayant la même valeur pour pour ces champs.

Exemple 9 :

Voici la syntaxe pour définir l'attribut Id en tant que clé primaire dans une table Employes.

                                CREATE TABLE Employes(
                                    Id INT              NOT NULL,
                                    Nom VARCHAR (20)    NOT NULL,
                                    Age  INT            NOT NULL,
                                    Salaire   DECIMAL (18, 2),       
                                    PRIMARY KEY (Id)
                                );
                            
Exemple 10 :

Pour créer une contrainte PRIMARY KEY sur la colonne "Id" alors que la table Employes existe déjà, utilisez la syntaxe SQL suivante :

                                ALTER TABLE Employes
                                    ADD PRIMARY KEY (ID);
                            
Attention ! Si vous utilisez l'instruction ALTER TABLE pour ajouter une clé primaire, les colonnes de clé primaire doivent déjà avoir été déclarées comme ne contenant pas de valeurs NULL (lors de la création de la table).
Exemple 11 :

Pour définir une contrainte PRIMARY KEY sur plusieurs colonnes, utilisez la syntaxe donnée ci-dessous.

                                CREATE TABLE Employes(
                                    Id INT              NOT NULL,
                                    Nom VARCHAR (20)    NOT NULL,
                                    Age  INT            NOT NULL,
                                    Salaire   DECIMAL (18, 2),       
                                    PRIMARY KEY (Id, Nom)
                                );
                            
Exemple 12 :

Pour créer une contrainte PRIMARY KEY sur les colonnes "Id" et "Nom" alors que la table Employes existe déjà, utilisez la syntaxe suivante :

                                ALTER TABLE Employes
                                    ADD PRIMARY KEY (Id, Nom);
                            

Vous pouvez supprimer les contraintes de clé primaire de la table avec la syntaxe donnée ci-dessous.

                                ALTER TABLE Employes DROP PRIMARY KEY ;
                            

Contrainte FOREIGN KEY

Une clé étrangère est une clé utilisée pour relier deux tables. Ceci est parfois appelé aussi clé de référencement.

Une clé étrangère est une colonne ou une combinaison de colonnes dont les valeurs correspondent à une clé primaire dans une autre table.

La relation entre 2 tables correspond à la clé primaire dans l'une des tables avec une clé étrangère dans la seconde table.

Exemple 13 :

Considérez la structure des deux tableaux suivants.

                                CREATE TABLE Employes(
                                    Id INT              NOT NULL,
                                    Nom VARCHAR (20)    NOT NULL,
                                    Age  INT            NOT NULL,
                                    Salaire   DECIMAL (18, 2),       
                                    PRIMARY KEY (Id, Nom)
                                );
                            
                                CREATE TABLE Conges(
                                    Id INT              NOT NULL,
                                    Date_debut  DATE,
                                    Date_fin  DATE,
                                    ID_EMP  INT REFERENCES Employes(Id),    
                                    PRIMARY KEY (Id)
                                );
                            

Ou

                                CREATE TABLE Conges(
                                    Id INT              NOT NULL,
                                    Date_debut  DATE    NOT NULL,
                                    Date_fin  DATE      NOT NULL,
                                    ID_EMP  INT,    
                                    PRIMARY KEY (Id),
                                    FOREIGN KEY (ID_EMP) REFERENCES Employes(Id)
                                );
                            
Exemple 14 :

Si la table Conges a déjà été créée et que la clé étrangère n'a pas encore été définie, utilisez la syntaxe suivante pour spécifier une clé étrangère en modifiant une table.

                                ALTER TABLE Conges
                                    ADD FOREIGN KEY (ID_EMP) REFERENCES Employes(Id);
                            

Pour supprimer une contrainte FOREIGN KEY, utilisez la syntaxe suivante :

                                ALTER TABLE Conges
                                    DROP FOREIGN KEY;
                            

Suppression des contraintes

Toute contrainte que vous avez définie peut être supprimée à l'aide de la commande ALTER TABLE avec l'option DROP CONSTRAINT.

Syntaxe :
                                ALTER TABLE Nom_table DROP CONSTRAINT nom_contrainte;
                            

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :