Aller au contenu
Encyclopédie informatique Édition 2026

Le langage SQL : interroger une base

Partie 4 sur 4

Niveau de lecture :

9Modifier les données

9.1INSERT

Un utilisateur qui dispose des droits nécessaires peut ajouter, modifier ou supprimer des lignes, que la théorie relationnelle appelle des tuples. L’ordre INSERT ajoute des lignes ; il est suivi de la clause INTO, du nom de la table et de la liste des colonnes à remplir ; les colonnes omises reçoivent leur valeur par défaut, le plus souvent NULL. Les valeurs sont données de deux façons :

-- avec VALUES : une ou plusieurs lignes, valeurs dans l'ordre des colonnes
INSERT INTO occaz (Marque, Modele, Serie, Numero, Compteur)
VALUES ('Fiat', 'Punto', 'GTI', '8941 UD 61', 80232),
       ('Audi', 'A4', 'Quattro', '7846 AZS 75', 21350);

-- avec SELECT : autant de lignes que la requête en renvoie
INSERT INTO archives (Marque, Modele, Numero)
SELECT Marque, Modele, Numero FROM occaz WHERE Compteur > 150000;

Quand on remplit toutes les colonnes, dans l’ordre de la table, la liste des colonnes est facultative, mais la donner rend la requête plus robuste aux évolutions de la table. Les chaînes de caractères doivent être délimitées, par des apostrophes selon la norme. On précise parfois qu’on ne peut pas lire, dans le SELECT, la table dans laquelle on insère : c’était une limite de certains SGBD de l’époque, pas une règle de SQL.

9.2UPDATE

L’ordre UPDATE modifie des lignes existantes ; on parle aussi de mise à jour. La clause SET indique la nouvelle valeur de chaque colonne, constante, expression ou résultat d’une sous-requête ; la clause WHERE désigne les lignes concernées :

UPDATE occaz
SET Compteur = 98000
WHERE Numero = '8562 EV 23';

9.3DELETE

L’ordre DELETE supprime des lignes : il est suivi de FROM, du nom de la table, puis d’une clause WHERE qui désigne les lignes à supprimer.

DELETE FROM occaz
WHERE Compteur > 180000;

Ces ordres sont à utiliser avec précaution. Un UPDATE ou un DELETE sans WHERE s’applique à toutes les lignes de la table (exercice 7). On qualifie la suppression d’irréversible ; c’est vrai une fois la modification validée, mais on peut se protéger : vérifier d’abord, avec un SELECT utilisant la même condition, quelles lignes seront touchées ; travailler dans une transaction, qui permet d’annuler avec ROLLBACK tant qu’on n’a pas validé avec COMMIT (voir les bases de données) ; disposer de sauvegardes.

BEGIN;
DELETE FROM occaz WHERE Compteur > 180000;
-- vérifier le nombre de lignes supprimées, puis :
COMMIT;      -- ou ROLLBACK; pour tout annuler

Lorsque des tables sont liées, par exemple des commandes qui font référence à des clients, il faut supprimer d’abord les lignes de la table qui fait référence, ici les commandes, puis celles de la table référencée, les clients : on parle de suppression en cascade ascendante. Les SGBD actuels peuvent l’automatiser grâce aux contraintes de clés étrangères, avec l’option ON DELETE CASCADE, ou au contraire refuser la suppression d’un client qui a encore des commandes (voir SQL : tables, contraintes et droits).

Pour s’exercer

Exercice 7 : la condition oubliée

Une employée veut corriger le compteur de la Ford et tape UPDATE occaz SET Compteur = 98000;, puis valide. Que s’est-il passé ? Comment l’éviter ?

Voir la réponse

Sans clause WHERE, la mise à jour s’applique à toutes les lignes : les six voitures ont désormais 98 000 km, et les anciennes valeurs sont perdues. Il faut restaurer la table depuis une sauvegarde. Pour l’éviter : écrire d’abord le SELECT avec la condition, SELECT * FROM occaz WHERE Numero = '8562 EV 23', vérifier le résultat, puis le transformer en UPDATE ; travailler dans une transaction et contrôler le nombre de lignes modifiées, que le SGBD affiche, avant de valider ; activer dans l’outil le mode qui refuse les mises à jour sans clé dans le WHERE, comme le « mode sûr » de MySQL ; et ne pas donner aux comptes du quotidien le droit de modifier les tables de production.

10Pour aller plus loinApprofondir

10.1CASE et les fonctions

L’expression CASE calcule une valeur selon des conditions, comme un « si… alors… sinon » à l’intérieur d’une requête. Les SGBD fournissent aussi de nombreuses fonctions sur les chaînes, les nombres et les dates, dont les noms varient malheureusement d’un système à l’autre.

SELECT Marque, Modele,
       CASE
           WHEN Compteur IS NULL THEN 'inconnu'
           WHEN Compteur < 50000 THEN 'faible'
           WHEN Compteur < 150000 THEN 'moyen'
           ELSE 'élevé'
       END AS kilometrage
FROM occaz;

10.2Les fonctions de fenêtrage

Les fonctions de fenêtrage, apparues dans SQL:2003, calculent une valeur pour chaque ligne à partir d’un ensemble de lignes voisines, sans les regrouper. Elles permettent les classements, les totaux cumulés ou les comparaisons avec la ligne précédente :

SELECT Marque, Modele, Compteur,
       RANK() OVER (PARTITION BY Marque ORDER BY Compteur DESC) AS rang,
       AVG(Compteur) OVER (PARTITION BY Marque) AS moyenne_marque
FROM occaz;

Chaque voiture garde sa ligne, accompagnée de son rang dans sa marque et de la moyenne de sa marque : un calcul qui exigerait, sans ces fonctions, des sous-requêtes ou des jointures complexes.

10.3Comprendre l’exécution

La commande EXPLAIN, disponible dans la plupart des SGBD, affiche le plan d’exécution choisi par l’optimiseur : quelles tables sont lues en entier, quels index sont utilisés, dans quel ordre se font les jointures. C’est le premier outil pour comprendre pourquoi une requête est lente, et décider de créer un index (voir SQL : tables, contraintes et droits).

11SQL dans les programmes

Les applications envoient leurs requêtes au SGBD par l’intermédiaire de bibliothèques, appelées pilotes ou connecteurs, disponibles pour tous les langages. Beaucoup de projets utilisent aussi un outil de correspondance objet-relationnel (en anglais Object-Relational Mapping, ORM), qui génère le SQL à partir d’objets du programme, comme Hibernate en Java, Entity Framework en C# ou SQLAlchemy en Python (voir la programmation orientée objet). Ces outils font gagner du temps, mais il reste indispensable de comprendre le SQL qu’ils produisent, notamment pour les performances.

La règle d’or est de ne jamais construire une requête en collant du texte saisi par l’utilisateur, mais d’utiliser des requêtes paramétrées, où les valeurs sont transmises séparément du texte de la requête :

# Python, avec la bibliothèque standard sqlite3
cur.execute(
    "SELECT * FROM occaz WHERE Marque = ? AND Compteur < ?",
    (marque_saisie, plafond)
)

Le SGBD reçoit d’un côté la structure de la requête, avec des emplacements marqués par ?, de l’autre les valeurs : quoi que contienne la saisie, elle sera traitée comme une simple donnée, jamais comme du code SQL (coin cyber).

SQL a par ailleurs largement débordé des bases relationnelles classiques : les entrepôts de données dans le cloud, les moteurs de traitement de très gros volumes et des outils d’analyse comme DuckDB l’utilisent pour interroger des fichiers de données (voir le big data). Et les assistants d’intelligence artificielle savent désormais traduire une question en français en requête SQL ; c’est pratique, à condition de relire la requête et de limiter les droits de ce qui l’exécute (voir programmer avec l’IA).

Sécurité de l’information

Le coin cyber

SQL est la porte d’entrée des données. Mal utilisé, il devient la porte d’entrée des attaquants : l’injection SQL fait partie depuis plus de vingt-cinq ans des failles les plus exploitées du Web. Les attaques sont décrites ici dans leur principe seulement.

C.1L’injection SQL

Quand un programme fabrique une requête en collant dans son texte ce que l’utilisateur a saisi, la saisie peut contenir des caractères spéciaux de SQL, comme l’apostrophe, qui terminent prématurément une chaîne et permettent d’ajouter des instructions. L’attaquant change ainsi le sens de la requête : contourner une vérification de mot de passe, lire des tables entières, voire modifier ou effacer des données. C’est l’injection SQL (voir l’injection SQL). La parade est simple et systématique : les requêtes paramétrées (section 11), qui séparent la structure de la requête et les valeurs. Les outils de correspondance objet-relationnel les utilisent par défaut, à condition de ne pas les contourner en écrivant du SQL brut assemblé à la main.

C.2Le moindre privilège

Le compte avec lequel une application se connecte ne doit pouvoir faire que ce dont elle a besoin : un site de consultation n’a besoin que de SELECT sur quelques tables, pas de DELETE ni de DROP. Si une injection réussit malgré tout, les dégâts sont limités aux droits de ce compte. Les vues et les droits par colonne permettent d’aller plus loin, en masquant les données sensibles (voir SQL : tables, contraintes et droits).

C.3Les messages d’erreur trop bavards

Un message d’erreur SQL affiché tel quel à l’utilisateur révèle la structure de la base : noms de tables, de colonnes, type de SGBD. C’est une mine d’informations pour un attaquant qui tâtonne. Les erreurs doivent être journalisées côté serveur, et l’utilisateur ne voir qu’un message générique.

C.4Les requêtes écrites par une IA

Les assistants d’intelligence artificielle génèrent du SQL de plus en plus souvent, et certains agents l’exécutent eux-mêmes. Une requête générée peut être fausse, lente ou destructrice, comme l’a montré l’incident de juillet 2025 évoqué dans les anecdotes. Un agent ne doit jamais disposer d’un accès en écriture à une base de production ; il doit travailler sur une copie ou avec un compte en lecture seule, et toute modification doit être relue et validée par une personne (voir les agents d’IA).

C.5Idée reçue

« Il suffit de supprimer les apostrophes des saisies pour empêcher l’injection SQL. » Faux. Il existe de nombreuses façons de contourner un tel filtre : valeurs numériques sans apostrophe, autres encodages des caractères, particularités de chaque SGBD. Le filtrage abîme aussi des données légitimes, comme les noms « O’Neil » ou « d’Artagnan ». Seules les requêtes paramétrées règlent le problème à la racine.

C.6Bonnes pratiques

Développeur

  • Utiliser exclusivement des requêtes paramétrées, y compris pour les valeurs qui semblent sûres.
  • Vérifier les conditions avec un SELECT avant tout UPDATE ou DELETE ; travailler dans des transactions.
  • Ne jamais afficher les erreurs SQL brutes ; relire le SQL généré par les outils et les assistants.

Organisation

  • Donner à chaque application et à chaque agent un compte aux droits minimaux.
  • Séparer strictement bases de développement, de test et de production.
  • Journaliser les requêtes sensibles, surveiller les extractions massives, tester les restaurations de sauvegarde.

Référentiels : OWASP (Open Worldwide Application Security Project), SQL Injection Prevention Cheat Sheet et Query Parameterization Cheat Sheet · MITRE, CWE-89 (Improper Neutralization of Special Elements used in an SQL Command) · CNIL, Guide de la sécurité des données personnelles (2024).

Références

  1. D. D. Chamberlin, R. F. Boyce, « SEQUEL: A Structured English Query Language », ACM SIGFIDET Workshop, 1974.
  2. E. F. Codd, « A Relational Model of Data for Large Shared Data Banks », Communications of the ACM, 1970.
  3. ISO/IEC 9075:2023, Information technology — Database languages — SQL.
  4. C. J. Date, SQL and Relational Theory, 3e éd., O’Reilly, 2015.
  5. M. Winand, SQL Performance Explained, 2012 ; traduction française SQL : au cœur des performances.

Voir aussi

Citer cet article

« Le langage SQL : interroger une base », Encyclopédie informatique, révision du 26 octobre 2026.