Apprendre le SQL : le guide pratique

Vous travaillez avec des fichiers Excel de 50 000 lignes, vous passez vingt minutes à faire des RECHERCHEV imbriquées, et un collègue vous dit “ce serait plus simple en SQL”. Vous acquiescez poliment sans savoir de quoi il parle. Pas de panique : SQL est probablement le langage le plus accessible de l’informatique, et en une journée de pratique, vous saurez faire des choses qui prendraient des heures dans un tableur.

SQL, c’est quoi et pourquoi s’y mettre ?

#

SQL - Structured Query Language - c’est la langue commune de toutes les bases de données relationnelles. Le truc date des années 1970 et pourtant MySQL, PostgreSQL, SQL Server, Oracle, SQLite le parlent tous couramment. Vous apprenez la syntaxe une fois, vous pouvez l’utiliser partout.

Ne confondez pas avec Python ou JavaScript : SQL ne sert pas à construire des applications. Son job, c’est d’interroger des données. Et franchement, il le fait mieux que n’importe quel outil visuel.

Qui s’en sert au quotidien ? Les analystes data évidemment, mais aussi les développeurs, les chefs de produit, les marketeurs qui veulent sortir leurs propres chiffres sans attendre le service IT. En 2026, savoir écrire une requête SQL est devenu aussi utile que maîtriser un tableur il y a dix ans.

Installer un environnement de pratique

#

Pour suivre ce guide, vous avez besoin d’un endroit où exécuter des requêtes. Deux options :

Option rapide (zéro installation) : ouvrez SQLite Online ou DB Fiddle dans votre navigateur. Vous pouvez taper des requêtes immédiatement.

Option locale (recommandée pour aller plus loin) : installez PostgreSQL et DBeaver (un client graphique gratuit). Sur Mac, via Homebrew :

brew install postgresql@16
brew services start postgresql@16

Créons une base de données d’exemple - une boutique en ligne fictive :

-- Création des tables
CREATE TABLE clients (
    id SERIAL PRIMARY KEY,
    nom VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE,
    ville VARCHAR(80),
    date_inscription DATE DEFAULT CURRENT_DATE
);

CREATE TABLE commandes (
    id SERIAL PRIMARY KEY,
    client_id INTEGER REFERENCES clients(id),
    montant DECIMAL(10, 2),
    statut VARCHAR(20) DEFAULT 'en_attente',
    date_commande DATE DEFAULT CURRENT_DATE
);

-- Insertion de données fictives
INSERT INTO clients (nom, email, ville) VALUES
    ('Marie Dupont', 'marie@example.com', 'Lyon'),
    ('Jean Martin', 'jean@example.com', 'Paris'),
    ('Amina Benali', 'amina@example.com', 'Marseille'),
    ('Lucas Bernard', 'lucas@example.com', 'Lyon'),
    ('Sophie Petit', 'sophie@example.com', 'Bordeaux');

INSERT INTO commandes (client_id, montant, statut, date_commande) VALUES
    (1, 89.90, 'livree', '2026-03-15'),
    (1, 245.00, 'en_cours', '2026-03-28'),
    (2, 32.50, 'livree', '2026-03-10'),
    (3, 178.00, 'livree', '2026-03-20'),
    (3, 55.00, 'annulee', '2026-03-22'),
    (4, 410.00, 'en_cours', '2026-04-01');

Copiez-collez ces requêtes dans votre éditeur SQL. Vous avez maintenant une base avec des clients et des commandes sur laquelle pratiquer.

Les requêtes de base : SELECT, WHERE, ORDER BY

#

La requête SELECT est le pain quotidien de SQL. Elle récupère des données depuis une table.

-- Tous les clients
SELECT * FROM clients;

-- Seulement le nom et la ville
SELECT nom, ville FROM clients;

-- Filtrer : uniquement les clients de Lyon
SELECT nom, email FROM clients WHERE ville = 'Lyon';

-- Trier par nom alphabétique
SELECT nom, ville FROM clients ORDER BY nom;

-- Combiner filtre et tri
SELECT nom, email
FROM clients
WHERE ville != 'Paris'
ORDER BY nom DESC;

Le mot-clé WHERE accepte les opérateurs classiques (=, !=, >, <, >=, <=) et des opérateurs spécifiques à SQL :

-- Commandes entre 50 et 200 euros
SELECT * FROM commandes WHERE montant BETWEEN 50 AND 200;

-- Clients de Lyon ou Marseille
SELECT * FROM clients WHERE ville IN ('Lyon', 'Marseille');

-- Emails contenant 'example'
SELECT * FROM clients WHERE email LIKE '%example%';

Notez le % qui joue le rôle de joker : LIKE '%martin%' trouvera “jean.martin@mail.com” comme “martinique@test.fr”.

Les jointures : croiser les données

#

C’est là que SQL devient vraiment intéressant. Vos clients sont dans une table, les commandes dans une autre - et vous avez besoin de croiser les deux pour savoir qui a acheté quoi. Les jointures, c’est la clé de voûte du langage.

-- Afficher chaque commande avec le nom du client
SELECT
    clients.nom,
    commandes.montant,
    commandes.statut,
    commandes.date_commande
FROM commandes
JOIN clients ON commandes.client_id = clients.id;

-- Avec des alias, c'est plus lisible
SELECT
    c.nom AS client,
    co.montant,
    co.statut
FROM commandes co
JOIN clients c ON co.client_id = c.id
WHERE co.statut = 'livree'
ORDER BY co.montant DESC;

JOIN (qu’on appelle aussi INNER JOIN) ne garde que les lignes qui matchent des deux côtés. Un client qui n’a jamais rien commandé ? Il disparaît du résultat. Pour le garder quand même, il y a LEFT JOIN :

-- Tous les clients, avec ou sans commande
SELECT
    c.nom,
    COALESCE(co.montant, 0) AS montant
FROM clients c
LEFT JOIN commandes co ON c.id = co.client_id;

COALESCE remplace les valeurs nulles par une valeur par défaut - ici 0. Très pratique pour les rapports.

Agrégation : résumer les données

#

Si vous avez déjà passé du temps dans les tableaux croisés dynamiques d’Excel, les agrégations SQL vont vous plaire. Même principe - regrouper, compter, additionner - mais sans naviguer dans une douzaine de menus. Et surtout, le résultat est reproductible : vous gardez la requête, pas juste le tableau final.

-- Nombre total de commandes
SELECT COUNT(*) AS nombre_commandes FROM commandes;

-- Montant moyen, min et max
SELECT
    ROUND(AVG(montant), 2) AS moyenne,
    MIN(montant) AS minimum,
    MAX(montant) AS maximum,
    SUM(montant) AS total
FROM commandes
WHERE statut != 'annulee';

-- Nombre de commandes par client
SELECT
    c.nom,
    COUNT(co.id) AS nb_commandes,
    SUM(co.montant) AS total_depense
FROM clients c
LEFT JOIN commandes co ON c.id = co.client_id
GROUP BY c.nom
ORDER BY total_depense DESC;

GROUP BY fait exactement ce que son nom indique : il regroupe les lignes par valeur commune. Ici, on obtient une ligne par client avec son total de commandes. Bien plus souple que le “regrouper par” d’un tableau croisé dynamique.

Pour filtrer les groupes (pas les lignes individuelles), utilisez HAVING :

-- Clients ayant dépensé plus de 100 euros au total
SELECT
    c.nom,
    SUM(co.montant) AS total
FROM clients c
JOIN commandes co ON c.id = co.client_id
WHERE co.statut != 'annulee'
GROUP BY c.nom
HAVING SUM(co.montant) > 100;

La distinction entre WHERE et HAVING piège beaucoup de débutants. Retenez cette règle : WHERE filtre avant l’agrégation, HAVING filtre après.

Les sous-requêtes et les cas pratiques métier

#

Il arrive qu’une seule requête ne suffise pas - vous avez besoin du résultat d’un premier calcul pour nourrir le suivant. La sous-requête, c’est littéralement une requête nichée dans une autre. Ça paraît tordu, mais en pratique c’est assez naturel :

-- Le client qui a la commande la plus élevée
SELECT nom FROM clients
WHERE id = (
    SELECT client_id FROM commandes
    ORDER BY montant DESC
    LIMIT 1
);

-- Clients qui n'ont jamais commandé
SELECT nom, email FROM clients
WHERE id NOT IN (
    SELECT DISTINCT client_id FROM commandes
);

Autre outil très utile - l’expression CASE, l’équivalent du SI() d’Excel :

-- Catégoriser les commandes par montant
SELECT
    c.nom,
    co.montant,
    CASE
        WHEN co.montant < 50 THEN 'Petit panier'
        WHEN co.montant < 200 THEN 'Panier moyen'
        ELSE 'Gros panier'
    END AS categorie
FROM commandes co
JOIN clients c ON co.client_id = c.id;

Avec tout ça dans votre boîte à outils, vous couvrez facilement 80 % de ce qu’on demande à un analyste ou un dev au quotidien. Les sujets avancés - CTE, fonctions de fenêtrage, procédures stockées - pourront attendre que vous ayez un vrai besoin dessus.

Ressources et prochaines étapes

#

Bon, vous avez les bases. Reste à passer de “j’ai compris les exemples du tuto” à “je me débrouille seul”. La recette est simple : des données réelles et de la répétition.

Téléchargez un dataset sur Kaggle - les jeux de données e-commerce ou ventes sont parfaits pour ça. Importez-le dans PostgreSQL et posez-vous des questions concrètes : quel produit rapporte le plus ? Quel mois est le plus creux ? Quels clients n’ont rien commandé depuis six mois ? C’est en répondant à de vraies questions qu’on progresse.

Côté exercices structurés, SQLZoo corrige vos requêtes en temps réel - idéal pour les deux premières semaines. LeetCode SQL monte d’un cran et prépare aux entretiens techniques, si c’est votre objectif.

Mon conseil : misez sur PostgreSQL. C’est la base open source la plus riche et la plus demandée. Une fois à l’aise dessus, MySQL ou SQL Server ne vous poseront aucun problème.

Et sur un CV, SQL fait la différence - pas que pour les devs. Un chef de projet qui tire ses propres données, un marketeur autonome sur ses rapports : les recruteurs adorent ça. Pour aller plus loin côté data, combinez avec Python et la bibliothèque pandas. Ce duo ouvre les portes de la data analyse et du machine learning.

Si vous visez une certification officielle, notre guide des certifications IT liste celles que les recruteurs reconnaissent vraiment.