Que vous soyez en pleine révision pour votre BTS SIO, en préparation d’un entretien technique ou simplement en train de coder à 23 h avec un trou de mémoire sur la syntaxe d’un LEFT JOIN, une bonne sql language cheat sheet peut vous sauver la mise. J’ai compilé ici tout ce que j’utilise au quotidien, de la requête SELECT la plus simple aux window functions les plus redoutées en entretien. Gardez cette page dans vos favoris : elle est faite pour ça.

Les 5 commandes SQL de base à connaître absolument

Quand on me demande « what are the 5 basic SQL commands? », je réponds toujours par les mêmes cinq piliers. Ce sont les commandes que vous utiliserez dans 80 % de vos projets, que ce soit en développement web, en data ou en administration de bases de données.

1. SELECT : lire des données

La commande la plus utilisée. Elle permet de récupérer des données depuis une ou plusieurs tables.

SELECT prenom, nom, email
FROM utilisateurs
WHERE actif = 1;

Pour sélectionner toutes les colonnes, utilisez l’astérisque :

SELECT * FROM produits;

2. INSERT : ajouter des données

INSERT INTO utilisateurs (prenom, nom, email)
VALUES ('Marie', 'Dupont', '[email protected]');

Vous pouvez insérer plusieurs lignes en une seule requête :

INSERT INTO utilisateurs (prenom, nom, email)
VALUES 
  ('Marie', 'Dupont', '[email protected]'),
  ('Paul', 'Martin', '[email protected]');

3. UPDATE : modifier des données

UPDATE utilisateurs
SET email = '[email protected]'
WHERE id = 42;

Attention : sans clause WHERE, toutes les lignes de la table seront modifiées. C’est une erreur classique que je vois régulièrement chez mes étudiants.

4. DELETE : supprimer des données

DELETE FROM utilisateurs
WHERE date_inscription < '2020-01-01';

Même vigilance ici : un DELETE sans WHERE vide toute la table.

5. CREATE : créer des structures

CREATE TABLE commandes (
  id INT PRIMARY KEY AUTO_INCREMENT,
  utilisateur_id INT NOT NULL,
  montant DECIMAL(10,2),
  date_commande DATE DEFAULT CURRENT_DATE,
  FOREIGN KEY (utilisateur_id) REFERENCES utilisateurs(id)
);

Ces cinq commandes constituent le socle de tout développeur. Si vous préparez des exercices SQL, commencez par les maîtriser parfaitement avant de passer à la suite.

DDL, DML, DCL et TCL : les 4 types de SQL

SQL n’est pas un langage monolithique. Il se découpe en quatre sous-langages, chacun dédié à un aspect précis de la gestion de bases de données. Comprendre cette classification, c’est comprendre l’architecture même du langage.

DDL en pratique

Le DDL sert à définir la structure de votre base. C’est le langage de l’architecte.

-- Modifier une table existante
ALTER TABLE utilisateurs ADD COLUMN telephone VARCHAR(20);

-- Supprimer une table (irréversible !)
DROP TABLE IF EXISTS logs_anciens;

-- Vider une table sans la supprimer
TRUNCATE TABLE sessions;

Pour bien documenter vos scripts DDL, pensez aux commentaires SQL. C’est une habitude que je recommande à tous mes étudiants en BTS SIO.

DML : le quotidien du développeur

Le DML regroupe les commandes que vous utiliserez le plus souvent. SELECT, INSERT, UPDATE et DELETE sont vos outils de travail quotidiens. Ce sont les commandes détaillées dans la section précédente.

DCL : la sécurité

-- Accorder des droits de lecture à un utilisateur
GRANT SELECT ON base_production.* TO 'lecteur'@'localhost';

-- Révoquer des droits
REVOKE DELETE ON base_production.* FROM 'stagiaire'@'localhost';

TCL : les transactions

Les transactions garantissent la cohérence de vos données. Si une opération échoue, vous pouvez annuler tout le bloc.

START TRANSACTION;

UPDATE comptes SET solde = solde - 100 WHERE id = 1;
UPDATE comptes SET solde = solde + 100 WHERE id = 2;

-- Si tout s'est bien passé
COMMIT;

-- En cas de problème
-- ROLLBACK;

La référence officielle des mots-clés SQL sur W3Schools reste une excellente ressource pour vérifier la syntaxe exacte de chaque commande.

Filtrer, trier et grouper vos données

Un SELECT sans filtre, c’est comme chercher un mot dans un dictionnaire en lisant chaque page. Les clauses WHERE, ORDER BY et GROUP BY sont vos accélérateurs.

WHERE : filtrer les résultats

-- Opérateurs de comparaison
SELECT * FROM produits WHERE prix > 50;
SELECT * FROM produits WHERE categorie = 'electronique';
SELECT * FROM produits WHERE prix BETWEEN 20 AND 100;
SELECT * FROM produits WHERE nom LIKE '%phone%';
SELECT * FROM produits WHERE categorie IN ('livre', 'musique', 'film');
SELECT * FROM produits WHERE description IS NOT NULL;

Pour approfondir les filtres combinés avec les jointures, consultez mon guide sur SQL WHERE et LEFT JOIN.

ORDER BY : trier les résultats

-- Tri ascendant (par défaut)
SELECT * FROM produits ORDER BY prix ASC;

-- Tri descendant
SELECT * FROM produits ORDER BY date_creation DESC;

-- Tri sur plusieurs colonnes
SELECT * FROM produits ORDER BY categorie ASC, prix DESC;

Pour des tris complexes sur plusieurs colonnes, j’ai détaillé les cas pratiques dans l’article sur SQL ORDER BY avec plusieurs colonnes.

GROUP BY et HAVING

-- Nombre de produits par catégorie
SELECT categorie, COUNT(*) AS nombre
FROM produits
GROUP BY categorie;

-- Filtrer les groupes avec HAVING
SELECT categorie, AVG(prix) AS prix_moyen
FROM produits
GROUP BY categorie
HAVING AVG(prix) > 30
ORDER BY prix_moyen DESC;

Point important : WHERE filtre les lignes avant le regroupement, HAVING filtre les groupes après. C’est une question classique en entretien.

LIMIT et OFFSET

-- Les 10 produits les plus chers
SELECT * FROM produits ORDER BY prix DESC LIMIT 10;

-- Pagination : page 3 avec 20 éléments par page
SELECT * FROM produits ORDER BY id LIMIT 20 OFFSET 40;

Les jointures SQL : INNER, LEFT, RIGHT, FULL

Les jointures sont le mécanisme qui donne toute sa puissance au modèle relationnel. Sans elles, vos tables seraient des îlots de données isolés.

INNER JOIN

Retourne uniquement les lignes qui ont une correspondance dans les deux tables.

SELECT u.prenom, u.nom, c.montant
FROM utilisateurs u
INNER JOIN commandes c ON u.id = c.utilisateur_id;

LEFT JOIN

Retourne toutes les lignes de la table de gauche, même celles sans correspondance à droite (valeurs NULL).

SELECT u.prenom, u.nom, c.montant
FROM utilisateurs u
LEFT JOIN commandes c ON u.id = c.utilisateur_id;

Très utile pour trouver les utilisateurs qui n’ont jamais passé commande :

SELECT u.prenom, u.nom
FROM utilisateurs u
LEFT JOIN commandes c ON u.id = c.utilisateur_id
WHERE c.id IS NULL;

RIGHT JOIN

L’inverse du LEFT JOIN : toutes les lignes de la table de droite sont conservées.

SELECT u.prenom, c.montant, c.date_commande
FROM utilisateurs u
RIGHT JOIN commandes c ON u.id = c.utilisateur_id;

FULL OUTER JOIN

Combine LEFT et RIGHT JOIN. Toutes les lignes des deux tables apparaissent, avec des NULL là où il n’y a pas de correspondance. Attention : MySQL ne supporte pas FULL OUTER JOIN nativement, il faut simuler avec un UNION.

-- PostgreSQL / SQL Server
SELECT u.prenom, c.montant
FROM utilisateurs u
FULL OUTER JOIN commandes c ON u.id = c.utilisateur_id;

-- Simulation MySQL avec UNION
SELECT u.prenom, c.montant
FROM utilisateurs u
LEFT JOIN commandes c ON u.id = c.utilisateur_id
UNION
SELECT u.prenom, c.montant
FROM utilisateurs u
RIGHT JOIN commandes c ON u.id = c.utilisateur_id;

Pour aller plus loin sur SQL UNION et ses variantes, j’ai rédigé un guide complet avec des cas concrets.

Sous-requêtes et CTE pour aller plus loin

Quand une seule requête ne suffit plus, les sous-requêtes et les CTE (Common Table Expressions) deviennent indispensables.

Sous-requêtes

-- Sous-requête dans WHERE
SELECT prenom, nom
FROM utilisateurs
WHERE id IN (
  SELECT utilisateur_id 
  FROM commandes 
  WHERE montant > 500
);

-- Sous-requête dans SELECT
SELECT 
  prenom,
  (SELECT COUNT(*) FROM commandes c WHERE c.utilisateur_id = u.id) AS nb_commandes
FROM utilisateurs u;

CTE (WITH)

Les CTE rendent vos requêtes complexes beaucoup plus lisibles. Je les recommande systématiquement à mes étudiants dès qu’une requête dépasse trois niveaux d’imbrication.

WITH clients_vip AS (
  SELECT utilisateur_id, SUM(montant) AS total_achats
  FROM commandes
  GROUP BY utilisateur_id
  HAVING SUM(montant) > 1000
)
SELECT u.prenom, u.nom, v.total_achats
FROM utilisateurs u
INNER JOIN clients_vip v ON u.id = v.utilisateur_id
ORDER BY v.total_achats DESC;

EXISTS vs IN

-- EXISTS est souvent plus performant sur de grosses tables
SELECT prenom, nom
FROM utilisateurs u
WHERE EXISTS (
  SELECT 1 FROM commandes c 
  WHERE c.utilisateur_id = u.id 
  AND c.montant > 500
);

Pour pratiquer ces concepts, mes exercices SQL guidés proposent des cas progressifs allant du simple SELECT aux CTE récursives.

Window functions : la puissance analytique de SQL

Les window functions (fonctions de fenêtrage) sont devenues un passage obligé dans les entretiens techniques. Contrairement à GROUP BY, elles ne réduisent pas le nombre de lignes : elles ajoutent un calcul sur une fenêtre de données tout en conservant chaque ligne du résultat.

ROW_NUMBER, RANK et DENSE_RANK

-- Numéroter les lignes dans chaque catégorie
SELECT 
  nom,
  categorie,
  prix,
  ROW_NUMBER() OVER (PARTITION BY categorie ORDER BY prix DESC) AS rang
FROM produits;

-- RANK laisse des trous en cas d'ex-aequo
-- DENSE_RANK n'en laisse pas
SELECT 
  nom,
  prix,
  RANK() OVER (ORDER BY prix DESC) AS rang_avec_trous,
  DENSE_RANK() OVER (ORDER BY prix DESC) AS rang_sans_trous
FROM produits;

LAG et LEAD

Ces fonctions permettent d’accéder aux lignes précédentes ou suivantes sans jointure. Idéal pour calculer des variations.

SELECT 
  date_vente,
  chiffre_affaires,
  LAG(chiffre_affaires, 1) OVER (ORDER BY date_vente) AS ca_precedent,
  chiffre_affaires - LAG(chiffre_affaires, 1) OVER (ORDER BY date_vente) AS variation
FROM ventes_mensuelles;

SUM, AVG et COUNT en window function

-- Cumul glissant du chiffre d'affaires
SELECT 
  date_vente,
  chiffre_affaires,
  SUM(chiffre_affaires) OVER (ORDER BY date_vente) AS cumul,
  AVG(chiffre_affaires) OVER (
    ORDER BY date_vente 
    ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
  ) AS moyenne_mobile_3
FROM ventes_mensuelles;

NTILE

-- Répartir les clients en 4 quartiles selon leurs dépenses
SELECT 
  prenom,
  total_achats,
  NTILE(4) OVER (ORDER BY total_achats DESC) AS quartile
FROM clients;

Les window functions sont essentielles pour des calculs comme COUNT DISTINCT sur des partitions, ou pour des arrondis sur des agrégats calculés ligne par ligne.

Fonctions d’agrégation et de manipulation

Au-delà des commandes structurelles, SQL offre un arsenal de fonctions intégrées pour transformer vos données à la volée.

Fonctions d’agrégation

Pour un guide complet sur le comptage de valeurs uniques, consultez mon article dédié au COUNT unique en SQL.

Fonctions sur les chaînes de caractères

SELECT 
  UPPER(nom) AS nom_majuscules,
  LOWER(email) AS email_normalise,
  CONCAT(prenom, ' ', nom) AS nom_complet,
  LENGTH(nom) AS longueur_nom,
  SUBSTRING(telephone, 1, 2) AS indicatif,
  TRIM(adresse) AS adresse_nettoyee,
  REPLACE(description, 'ancien', 'nouveau') AS description_maj
FROM utilisateurs;

Fonctions sur les dates

SELECT 
  NOW() AS date_heure_actuelle,
  CURDATE() AS date_du_jour,
  YEAR(date_inscription) AS annee,
  MONTH(date_inscription) AS mois,
  DATEDIFF(CURDATE(), date_inscription) AS jours_depuis_inscription,
  DATE_ADD(date_inscription, INTERVAL 1 YEAR) AS anniversaire
FROM utilisateurs;

CASE WHEN : la logique conditionnelle

SELECT 
  prenom,
  montant,
  CASE 
    WHEN montant >= 500 THEN 'Premium'
    WHEN montant >= 100 THEN 'Standard'
    ELSE 'Basique'
  END AS segment_client
FROM commandes;

La documentation officielle MySQL sur les fonctions intégrées reste la référence la plus fiable pour vérifier la compatibilité et la syntaxe exacte de chaque fonction.

Peut-on vraiment apprendre SQL en 7 jours ?

C’est une question que mes étudiants me posent régulièrement : can I learn SQL in 7 days? Ma réponse honnête : oui, mais avec des nuances.

En 7 jours de pratique sérieuse (2 à 3 heures par jour), vous pouvez maîtriser :

• Jour 1-2 : SELECT, WHERE, ORDER BY, les opérateurs de comparaison
• Jour 3 : INSERT, UPDATE, DELETE, CREATE TABLE
• Jour 4 : GROUP BY, HAVING, fonctions d’agrégation
• Jour 5 : INNER JOIN, LEFT JOIN, RIGHT JOIN
• Jour 6 : Sous-requêtes, UNION, CASE WHEN
• Jour 7 : Révision, exercices pratiques, premières window functions

Ce planning vous donnera une base solide pour travailler sur des projets réels. En revanche, la maîtrise avancée (optimisation des requêtes, indexation, CTE récursives, tuning de performance) demande des mois de pratique régulière.

Mon conseil : ne vous contentez pas de lire la syntaxe. Écrivez des requêtes chaque jour sur une vraie base de données. J’utilise souvent la base d’exemple « Sakila » de MySQL ou « Chinook » pour PostgreSQL. Ce sont des jeux de données suffisamment riches pour pratiquer tous les concepts de cette cheat sheet.

Pour structurer votre apprentissage, la référence francophone SQL.sh propose des cours progressifs particulièrement bien adaptés aux débutants. Et si vous préférez apprendre par la pratique, mes exercices SQL progressifs suivent exactement cette progression en 7 jours.

Bonnes pratiques pour écrire du SQL propre

Après des années de formation et de développement, voici les règles d’or que je transmets systématiquement à mes étudiants.

Lisibilité

• Mots-clés en majuscules : SELECT, FROM, WHERE, JOIN. C’est une convention universelle qui améliore considérablement la lisibilité.
• Un mot-clé par ligne pour les requêtes de plus de deux clauses.
• Indentation cohérente : alignez les colonnes, les conditions et les jointures.
• Alias explicites : préférez u pour utilisateurs plutôt que t1.

Performance

• Évitez SELECT * en production : listez uniquement les colonnes nécessaires.
• Indexez les colonnes utilisées dans WHERE, JOIN et ORDER BY.
• Préférez EXISTS à IN pour les sous-requêtes sur de grosses tables.
• Utilisez EXPLAIN pour analyser le plan d’exécution de vos requêtes lentes.

-- Analyser les performances d'une requête
EXPLAIN SELECT u.prenom, COUNT(c.id)
FROM utilisateurs u
LEFT JOIN commandes c ON u.id = c.utilisateur_id
GROUP BY u.id;

Sécurité

• Utilisez des requêtes préparées (prepared statements) pour éviter les injections SQL. C’est non négociable.
• Appliquez le principe du moindre privilège avec GRANT et REVOKE.
• Sauvegardez avant tout DDL destructif (DROP, TRUNCATE).

La cheat sheet OWASP sur la prévention des injections SQL est un document de référence que tout développeur devrait connaître.