PostgreSQL Contraintes

Les contraintes PostgreSQL sont utilisées pour spécifier des règles relatives aux données d'une table.

Si un comportement enfreint des contraintes, ce comportement sera interrompu par la contrainte.

Les contraintes peuvent être spécifiées lors de la création de la table (via l'instruction CREATE TABLE), ou après la création de la table (via l'instruction ALTER TABLE).

Les contraintes garantissent l'exactitude et la fiabilité des données dans la base de données.

Les contraintes peuvent être au niveau colonne ou au niveau table. Les contraintes au niveau colonne s'appliquent uniquement à une colonne, tandis que les contraintes au niveau table s'appliquent à l'ensemble de la table.

Voici les contraintes couramment utilisées dans PostgreSQL.

NOT NULL: Indique qu'une colonne ne peut pas stocker de valeurs NULL.
UNIQUE: Garantit que les valeurs d'une colonne sont toutes uniques.
Clé PRIMARY : Une combinaison de NOT NULL et UNIQUE. Garantit qu'une colonne (ou une combinaison de deux colonnes ou plus) possède un identifiant unique, ce qui aide à trouver plus facilement et rapidement un enregistrement spécifique dans la table.
Clé FOREIGN : Garantit l'intégrité référentielle en assurant que les données d'une table correspondent aux valeurs d'une autre table.
CHECK : Garantit que les valeurs d'une colonne respectent une condition spécifiée.
EXCLUSION : Une contrainte d'exclusion garantit que si deux lignes quelconques sont comparées sur les colonnes ou expressions spécifiées à l'aide des opérateurs spécifiés, au moins l'une des comparaisons d'opérateurs renverra false ou null.

Contrainte NOT NULL

Par défaut, une colonne peut contenir des valeurs NULL. Si vous ne voulez pas qu'une colonne ait des valeurs NULL, vous devez définir cette contrainte sur cette colonne, en spécifiant que les valeurs NULL ne sont pas autorisées dans cette colonne.

NULL n'est pas la même chose que l'absence de données ; cela représente des données inconnues.

Exemple

L'exemple suivant crée une nouvelle table appelée COMPANY1 avec 5 champs, dont trois, ID, NAME et AGE, sont définis pour ne pas accepter de valeurs NULL :

CREATE TABLE COMPANY1(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Contrainte UNIQUE

La contrainte UNIQUE peut définir une colonne comme unique, ce qui évite les valeurs en double dans la même colonne.

Exemple

L'exemple suivant crée une nouvelle table appelée COMPANY3 avec 5 champs. Le champ AGE est défini sur UNIQUE, vous ne pouvez donc pas ajouter deux enregistrements ayant le même âge :

CREATE TABLE COMPANY3(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL UNIQUE,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

PRIMARY KEY

Lors de la conception d'une base de données, la PRIMARY KEY est très importante.

PRIMARY KEY, également appelée clé primaire, est l'identifiant unique de chaque enregistrement dans une table de données.

Il peut y avoir plusieurs colonnes définies avec UNIQUE, mais une seule colonne dans une table peut être définie comme PRIMARY KEY.

Nous pouvons utiliser la clé primaire pour référencer des lignes dans une table, et nous pouvons également créer des relations entre les tables en définissant la clé primaire comme clé étrangère dans d'autres tables.

Une clé primaire est une combinaison d'une contrainte NOT NULL et d'une contrainte UNIQUE.

Une table ne peut avoir qu'une seule clé primaire, qui peut être composée d'un ou plusieurs champs. Lorsque plusieurs champs sont utilisés comme clé primaire, on parle de clé composite.

Si une table définit une clé primaire sur un ou plusieurs champs, alors deux enregistrements ne peuvent pas avoir la même valeur dans ces champs.

Exemple

Ensuite, nous créons la table COMAPNY4, avec ID comme clé primaire :

CREATE TABLE COMPANY4(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Contrainte FOREIGN KEY

FOREIGN KEY, également appelée contrainte de clé étrangère, spécifie que les valeurs d'une colonne (ou d'un ensemble de colonnes) doivent correspondre à des valeurs apparaissant dans une ligne d'une autre table.

Habituellement, une FOREIGN KEY dans une table pointe vers une UNIQUE KEY (une clé avec une contrainte d'unicité) dans une autre table, maintenant ainsi l'intégrité référentielle entre les deux tables liées.

Exemple

L'exemple suivant crée une table COMPANY6 et ajoute 5 champs :

CREATE TABLE COMPANY6(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

L'exemple suivant crée une table DEPARTMENT1 et ajoute 3 champs. EMP_ID est la clé étrangère, faisant référence à l'ID de COMPANY6 :

CREATE TABLE DEPARTMENT1(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      references COMPANY6(ID)
);

Contrainte CHECK

La contrainte CHECK garantit que toutes les valeurs d'une colonne satisfont une certaine condition, c'est-à-dire qu'elle vérifie chaque enregistrement saisi. Si la condition est évaluée à false, l'enregistrement viole la contrainte et ne peut pas être inséré dans la table.

Exemple

Par exemple, l'exemple suivant crée une nouvelle table COMPANY5 avec cinq colonnes. Ici, nous ajoutons une contrainte CHECK sur la colonne SALARY, afin que le salaire ne puisse pas être zéro :

CREATE TABLE COMPANY5(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    CHECK(SALARY > 0)
);

Contrainte EXCLUSION

La contrainte EXCLUSION garantit que si deux lignes quelconques sont comparées sur les colonnes ou expressions spécifiées à l'aide des opérateurs spécifiés, au moins une des comparaisons d'opérateurs renverra false ou null.

Exemple

L'exemple suivant crée une table COMPANY7 avec 5 champs et utilise la contrainte EXCLUDE.

CREATE TABLE COMPANY7(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT,
   AGE            INT  ,
   ADDRESS        CHAR(50),
   SALARY         REAL,
   EXCLUDE USING gist
   (NAME WITH =,  -- 如果满足 NAME 相同，AGE 不相同则不允许插入，否则允许插入
   AGE WITH <>)   -- 其比较的结果是如果整个表达式返回 true，则不允许插入，否则允许
);

Ici, USING gist est un type d'index utilisé pour la construction et l'exécution.

Vous devez exécuter la commande CREATE EXTENSION btree_gist une fois pour chaque base de données. Cela installera l'extension btree_gist, qui définit des contraintes EXCLUDE sur les types de données scalaires simples.

Comme nous avons imposé que les âges doivent être égaux, vérifions cela en insérant des enregistrements dans la table :

INSERT INTO COMPANY7 VALUES(1, 'Paul', 32, 'California', 20000.00 );
INSERT INTO COMPANY7 VALUES(2, 'Paul', 32, 'Texas', 20000.00 );
-- 此条数据的 NAME 与第一条相同，且 AGE 与第一条也相同，故满足插入条件
INSERT INTO COMPANY7 VALUES(3, 'Allen', 42, 'California', 20000.00 );
-- 此数据与上面数据的 NAME 相同，但 AGE 不相同，故不允许插入

Les deux premiers sont ajoutés avec succès à la table COMPANY7, mais le troisième signalera une erreur :

ERROR:  conflicting key value violates exclusion constraint "company7_name_age_excl"
DETAIL:  Key (name, age)=(Paul, 42) conflicts with existing key (name, age)=(Paul, 32).

Supprimer les contraintes

Pour supprimer une contrainte, vous devez connaître son nom. Si vous connaissez déjà le nom, il est simple de supprimer la contrainte. Si vous ne connaissez pas le nom, vous devez trouver le nom généré par le système en utilisant\d table_nameVous pouvez trouver cette information.

La syntaxe générale est la suivante :

ALTER TABLE table_name DROP CONSTRAINT some_name;

Autres extensions

PostgreSQL Avancé

PostgreSQL Contraintes

Contrainte NOT NULL

Contrainte UNIQUE

PRIMARY KEY

Contrainte FOREIGN KEY

Contrainte CHECK

Contrainte EXCLUSION

Supprimer les contraintes