Découvrez comment utiliser la commande SQL `UPDATE` pour modifier les données existantes dans une table de votre base de données.
En tant que développeur, la maîtrise des bases de données relationnelles est essentielle. SQL, acronyme de Structured Query Language, est un langage facile à prendre en main, avec une syntaxe intuitive et simple. Il permet la création d’objets de base de données ainsi que l’interrogation de tables au sein de bases de données relationnelles.
Les requêtes SQL permettent d’effectuer des opérations CRUD : Créer, Lire, Mettre à Jour et Supprimer des enregistrements. Ces opérations sont fondamentales pour la manipulation de données.
L’instruction `UPDATE` en SQL est utilisée précisément pour modifier les informations stockées dans une table.
Dans ce guide, nous explorerons :
- La structure de la commande `UPDATE`.
- La manière de modifier des enregistrements en fonction d’une ou plusieurs conditions liées par des opérateurs logiques.
- Les précautions à prendre lors de l’exécution de la commande `UPDATE` afin d’éviter des modifications non intentionnelles.
Structure de la commande SQL `UPDATE`
La forme générale de la commande SQL `UPDATE` est la suivante :
UPDATE nom_de_la_table SET colonne = nouvelle_valeur WHERE condition;
Cette requête modifiera la valeur de la colonne spécifiée pour tous les enregistrements qui satisfont à la condition indiquée dans la clause `WHERE`.
Pour modifier plusieurs colonnes simultanément, la syntaxe se présente ainsi :
UPDATE nom_de_la_table SET colonne_1 = nouvelle_valeur_1, colonne_2 = nouvelle_valeur_2, ..., colonne_k = nouvelle_valeur_k WHERE condition;
Rappelons les notions de base d’une base de données relationnelle :
- Une table représente une entité.
- Les lignes de la table, appelées enregistrements, représentent une instance de cette entité.
- Les colonnes, aussi appelées champs ou attributs, définissent les caractéristiques de l’entité.
Exemples d’utilisation de la commande SQL `UPDATE`
Passons maintenant à la pratique avec quelques exemples concrets.
Prérequis
Avant de démarrer :
- Ce tutoriel utilise SQLite. Assurez-vous d’avoir SQLite et un outil comme DB Browser for SQLite installé pour une manipulation aisée de la base de données. Vous pouvez également utiliser MySQL ou PostgreSQL si vous le préférez.
- Si vous souhaitez reproduire l’exemple, vous aurez besoin de Python et du module Faker.
Création d’une table avec des données de test
Pour faciliter le suivi de ce tutoriel, vous pouvez utiliser le script Python ci-dessous pour créer une base de données `customer_db.db` et la remplir avec des données fictives. La bibliothèque Faker nous permet de générer des données aléatoires pour la table `customers` :
import sqlite3
from faker import Faker
import random
# Établir la connexion à la base de données
conn = sqlite3.connect('customer_db.db')
cur = conn.cursor()
# Créer la table "customers"
cur.execute('''CREATE TABLE customers (
customerID INTEGER PRIMARY KEY,
name TEXT,
city TEXT,
email TEXT,
num_orders INTEGER,
discount INTEGER DEFAULT 2)''')
# Initialisation de Faker
fake = Faker()
Faker.seed(42)
# Remplir la table avec des données fictives
for _ in range(15):
name = fake.name()
city = fake.city()
domain = fake.domain_name()
email = f"{name[:2]}.{city[:2]}@{domain}"
num_orders = random.choice(range(200))
cur.execute('INSERT INTO customers (name, city, email, num_orders)
VALUES (?,?,?,?)', (name,city,email,num_orders))
# Valider les changements et fermer la connexion
conn.commit()
cur.close()
conn.close()
Assurez-vous d’avoir Python 3.7 (ou une version ultérieure) ainsi que Faker installés dans votre environnement de développement. Vous pouvez installer le module Faker via pip :
pip install faker
Si vous disposez déjà d’une base de données et d’une table que vous souhaitez utiliser, vous pouvez les employer sans problème.
Exécution de notre première requête SQL
Notre table `customers` possède les colonnes suivantes :
- `customerID` : Clé primaire identifiant chaque client de manière unique.
- `name` : Nom du client.
- `city` : Ville du client.
- `email` : Adresse électronique du client.
- `num_orders` : Nombre de commandes passées par le client.
- `discount` : Pourcentage de remise accordé, avec une valeur par défaut de 2.
Vous pouvez utiliser l’interface en ligne de commande de SQLite ou un outil comme DB Browser for SQLite pour exécuter les requêtes et afficher les résultats.
Pour cet exemple, nous utiliserons les captures d’écran de DB Browser for SQLite.
Pour récupérer tous les enregistrements de la table `customers`, utilisez la requête suivante :
SELECT * FROM customers;
L’utilisation de `SELECT *` doit être limitée aux cas où cela est strictement nécessaire, mais elle est pratique pour nos besoins, car notre table est petite.
Mise à jour d’enregistrements avec une seule condition
Maintenant que nous connaissons la structure de notre table, procédons à la mise à jour de certains enregistrements.
Notez qu’après chaque commande `UPDATE`, nous exécuterons `SELECT * FROM customers` pour observer les changements.
Mise à jour d’un seul champ
Commençons par modifier la ville de l’enregistrement ayant `customerID` égal à 7 :
UPDATE customers SET city='Codeshire' WHERE customerID=7;
En sélectionnant tous les enregistrements de la table, nous constatons que la ville de l’enregistrement avec `customerID` égal à 7 a été mise à jour.
Mise à jour de plusieurs champs
Nous pouvons modifier plusieurs colonnes simultanément. L’exemple suivant change à la fois la ville et l’adresse email de l’enregistrement ayant l’`customerID` 1 :
UPDATE customers SET city='East Carlisle', email="[email protected]" WHERE customerID=1;
La requête suivante affiche le résultat :
Mise à jour de plusieurs enregistrements
Jusqu’à présent, nous avons utilisé `customerID`, qui est la clé primaire, afin de modifier des enregistrements uniques. Cependant, si la condition spécifiée dans la clause `WHERE` est vraie pour plusieurs enregistrements, la commande `UPDATE` les modifiera tous.
Par exemple, cette requête change le pourcentage de remise à 10 pour tous les clients ayant passé plus de 170 commandes :
UPDATE customers SET discount=10 WHERE num_orders > 170;
Le résultat de cette requête est le suivant :
L’exécution de cette commande a modifié trois enregistrements. Ils ont désormais une remise de 10, car ils avaient tous plus de 170 commandes.
Mise à jour d’enregistrements avec plusieurs conditions
Dans les exemples précédents, la clause `WHERE` contenait une seule condition. Il est fréquent d’utiliser plusieurs conditions liées par des opérateurs logiques.
Pour illustrer cela, nous allons fixer la remise à 5 pour les clients résidant dans une ville dont le nom commence par « New » et ayant passé plus de 100 commandes :
Voici la requête:
UPDATE customers SET DISCOUNT=5 WHERE city LIKE 'New%' AND num_orders>100;
Nous avons combiné deux conditions à l’aide de l’opérateur logique `AND`. Seuls les enregistrements qui satisfont aux deux conditions seront mis à jour.
Voici le résultat:
Précautions à prendre lors de l’utilisation de la commande SQL `UPDATE`
Dans tous les exemples précédents, nous avons inclus la clause `WHERE`. L’omission de cette clause peut avoir des conséquences indésirables.
Supposons que vous souhaitiez modifier la remise d’un seul client et que vous oubliez d’inclure la clause `WHERE` :
UPDATE customers SET DISCOUNT=25;
En exécutant cette commande et en consultant la table, vous constaterez que tous les enregistrements ont été mis à jour.
Il est donc crucial d’inclure la clause `WHERE` lorsque vous souhaitez modifier un sous-ensemble spécifique d’enregistrements. Si votre intention est de modifier une colonne pour tous les enregistrements, vous pouvez omettre la clause `WHERE`.
Dans l’exemple précédent, vous pourriez souhaiter appliquer une remise de 25 % à tous les clients, en prévision du Black Friday. Dans ce cas, l’absence de la clause `WHERE` est intentionnelle et correcte.
Conclusion
Voici un récapitulatif des points clés de ce guide :
- La commande SQL `UPDATE` permet de modifier les enregistrements existants dans une base de données.
- La clause `WHERE` spécifie les enregistrements qui doivent être mis à jour.
- L’omission de la clause `WHERE` entraîne la mise à jour de tous les enregistrements de la table.
Pour une référence rapide des commandes SQL, vous pouvez consulter une antisèche SQL.