Langage SQL

CRUD en SQL

Ajouter, Lire, mettre à jour et supprimer un enregistrement

Montre la syntaxe des différentes requêtes SQL permettant de gérer un enregistrement d’une table de base de données relationnelle.

On résume généralement les fonctions de bases de manipulations d’un enregistrement sous le terme de CRUD (create, read,update et delete). Pour chacune de ses actions, il existe une instruction SQL correspondante.

Sommaire

Présentation

Beaucoup d’applications que vous êtes amenés à développer utilisent des bases de données relationnelles pour sauvegarder les données qu’elles manipulent. Si vous n’utilisez pas de framework de maping objet relationnel, vous devrez, même si vous êtes développeur Java, PHP ou autre, être capable de définir en langage SQL au moins des requêtes d’ajout, suppression, mise à jour et recherche d’un enregistrement. C’est le but de l’exemple qui va suivre.

L’exemple utilisé

Nous allons voir maintenant la syntaxe correspondante à partir d’un exemple simple, une table contenant une liste de compositeurs définis par une clé numérique, un nom, un prénom et les années de naissance et de décè. La clé numérique sera générée automatiquement par le SGBD (champs auto_increment) cela nous permettra de voir comment prendre en compte cette caractéristique assez courante.

Nota : Les requêtes SQL ont été testées sur une base MySQL mais, s’agissant de commandes standards, elles devraient également fonctionner sur l’ensemble des SGBDR respectant la norme SQL.

Voici la structure de la table :

+---------------+-------------+------+-----+---------+----------------+
| Field         | Type        | Null | Key | Default | Extra          |
+---------------+-------------+------+-----+---------+----------------+
| CMP_ID        | bigint(20)  | NO   | PRI | NULL    | auto_increment |
| CMP_DECE      | smallint(6) | YES  |     | NULL    |                |
| CMP_NAISSANCE | smallint(6) | YES  |     | NULL    |                |
| CMP_NOM       | varchar(50) | YES  |     | NULL    |                |
| CMP_PRENOM    | varchar(50) | YES  |     | NULL    |                |
+---------------+-------------+------+-----+---------+----------------+

et son contenu :

mysql> select * from T_COMPOSITEURS_CMP;
+--------+-----------+------------------+---------+------------+
| CMP_ID | CMP_NOM   | CMP_PRENOM       | CMP_NEE | CMP_DECEDE |
+--------+-----------+------------------+---------+------------+
|      1 | Bach      | Johann Sebastian |    1685 |       1750 |
|      2 | Beethoven | Ludwig van       |    1770 |       1827 |
|      3 | Berg      | Alban            |    1885 |       1935 |
|      4 | Britten   | Benjamin         |    1913 |       1976 |
|      5 | Bruckner  | Anton            |    1824 |       1896 |
+--------+-----------+------------------+---------+------------+
5 rows in set (0.00 sec)

Voyons voir maintenant les différentes commandes.

CREATE : ajouter un enregistrement

Nous allons ajouter le compositeur Maurice Ravel

INSERT INTO T_COMPOSITEURS_CMP ( CMP_NOM, CMP_PRENOM, CMP_NEE, CMP_DECEDE ) VALUES ( 'Ravel', 'Maurice', 1875, 1937 );

Vérifions que notre enregistrement a bien été ajouté :

select * from T_COMPOSITEURS_CMP;
+--------+-----------+------------------+---------+------------+
| CMP_ID | CMP_NOM   | CMP_PRENOM       | CMP_NEE | CMP_DECEDE |
+--------+-----------+------------------+---------+------------+
|      1 | Bach      | Johann Sebastian |    1685 |       1750 |
|      2 | Beethoven | Ludwig van       |    1770 |       1827 |
|      3 | Berg      | Alban            |    1885 |       1935 |
|      4 | Britten   | Benjamin         |    1913 |       1976 |
|      5 | Bruckner  | Anton            |    1824 |       1896 |
|      6 | Ravel     | Maurice          |    1875 |       1937 |
+--------+-----------+------------------+---------+------------+
6 rows in set (0.00 sec)

Nous voyons que nous n’avons pas défini le champ CMP_ID et que c’est le SGBD qui l’initialise avec une nouvelle valeur. Par contre, lorsque l’on ne définit pas un champ qui n’est pas auto_increment, lors d’une insertion, ce dernier aura soit la valeur NULL soit, une valeur par défaut si vous en avez défini une lors de la définition de la table. Une erreur pourra être générée si vous ne définissez pas de valeur sur champ définit comme NOT NULL, sachant qu’un champ servant de clé primaire ne peut être NULL par définition.

READ : lire un enregistrement

Nous allons maintenant récupérer un enregistrement pour le lire. Pour cela, nous devrons utiliser la valeur de sa clé.

SELECT * FROM T_COMPOSITEURS_CMP WHERE CMP_ID = 6;

Ce qui donne :

+--------+---------+------------+---------+------------+
| CMP_ID | CMP_NOM | CMP_PRENOM | CMP_NEE | CMP_DECEDE |
+--------+---------+------------+---------+------------+
|      6 | Ravel   | Maurice    |    1875 |       1937 |
+--------+---------+------------+---------+------------+
1 row in set (0.03 sec)

UPDATE : mettre à jour un enregistrement

Maintenant, nous allons mettre à jour l’enregistrement que nous venons d’ajouter et qui est identifié par la clé de valeur 6 (en mettant les caractéristiques d’un autre compositeur par exemple).

UPDATE T_COMPOSITEURS_CMP SET CMP_NOM = 'Schuman', CMP_PRENOM = 'Robert', CMP_NEE = 1810, CMP_DECEDE = 1856 WHERE CMP_ID = 6;

ATTENTION : Ne surtout pas oublier la clause WHERE sinon, c’est l’ensemble des enregistrements de la table qui seront modifiés.

Vérifions que la mise à jour a bien été prise en compte :

select * from T_COMPOSITEURS_CMP;
+--------+-----------+------------------+---------+------------+
| CMP_ID | CMP_NOM   | CMP_PRENOM       | CMP_NEE | CMP_DECEDE |
+--------+-----------+------------------+---------+------------+
|      1 | Bach      | Johann Sebastian |    1685 |       1750 |
|      2 | Beethoven | Ludwig van       |    1770 |       1827 |
|      3 | Berg      | Alban            |    1885 |       1935 |
|      4 | Britten   | Benjamin         |    1913 |       1976 |
|      5 | Bruckner  | Anton            |    1824 |       1896 |
|      6 | Schuman   | Robert           |    1810 |       1856 |
+--------+-----------+------------------+---------+------------+
6 rows in set (0.00 sec)

DELETE : Supprimer un enregistrement

Pour la suppression d’un enregistrement, nous devrons également utiliser la valeur de la clé correspondant à la ligne à supprimer.

Supprimons l’enregistrement correspondant à la clé n°3 :

DELETE FROM T_COMPOSITEURS_CMP WHERE CMP_ID = 3;

Vérifions que l’enregistrement ayant la clé n° 3 (Alban Berg) a bien été supprimé :

mysql> select * from T_COMPOSITEURS_CMP;
+--------+-----------+------------------+---------+------------+
| CMP_ID | CMP_NOM   | CMP_PRENOM       | CMP_NEE | CMP_DECEDE |
+--------+-----------+------------------+---------+------------+
|      1 | Bach      | Johann Sebastian |    1685 |       1750 |
|      2 | Beethoven | Ludwig van       |    1770 |       1827 |
|      4 | Britten   | Benjamin         |    1913 |       1976 |
|      5 | Bruckner  | Anton            |    1824 |       1896 |
|      6 | Schuman   | Robert           |    1810 |       1856 |
+--------+-----------+------------------+---------+------------+
5 rows in set (0.00 sec)

IMPORTANT : Même remarque, ne pas oublier la clause WHERE sous peine de vider complètement la table.

Conclusion

Vous connaissez maintenant les 4 requêtes SQL permettant de gérer un enregistrement dans une base de données.

Développement

Article n° 80

Crée par: chris

Créé le: 29 novembre 2016

Modifié le: 29 novembre 2016

Nombre de visites: 451

Popularité: 20 %

Popularité absolue: 1

Langage SQL

Le NULL en SQL

Mots clés de cet article

SQL12