SQL est un langage déclaratif : on décrit ce que l’on veut, pas comment l’obtenir. Il est utilisé par tous les SGBD relationnels (PostgreSQL, MySQL, SQL Server, Oracle, SQLite). SQL se divise en plusieurs sous‑langages :

• DDL (Data Definition Language) – créer, modifier ou supprimer des structures (tables, index, vues).
• DML (Data Manipulation Language) – insérer, mettre à jour ou supprimer des données.
• DQL (Data Query Language) – interroger les données avec SELECT.
• DCL (Data Control Language) – gérer les droits (GRANT, REVOKE).
• TCL (Transaction Control Language) – gérer les transactions (COMMIT, ROLLBACK).

ISOSET propose des cursus complets pour maîtriser SQL, de la découverte aux requêtes avancées.

-- Créer une table
CREATE TABLE client (
    id_client INT PRIMARY KEY,
    nom VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE,
    date_inscription DATE DEFAULT CURRENT_DATE
);
-- Ajouter une colonne
ALTER TABLE client ADD COLUMN telephone VARCHAR(20);
-- Créer un index
CREATE INDEX idx_client_nom ON client(nom);
-- Supprimer une table
DROP TABLE client_tmp;

Les contraintes (NOT NULL, UNIQUE, PRIMARY KEY, FOREIGN KEY, CHECK) garantissent l’intégrité des données. ISOSET forme aux bonnes pratiques de modélisation et de normalisation.

-- Insérer une ligne
INSERT INTO client (id_client, nom, email) VALUES (1, 'Dupont', 'dupont@mail.com');
-- Insérer plusieurs lignes
INSERT INTO client (id_client, nom, email) VALUES 
    (2, 'Martin', 'martin@mail.com'),
    (3, 'Durand', 'durand@mail.com');
-- Mettre à jour
UPDATE client SET email = 'nouveau@mail.com' WHERE id_client = 1;
-- Supprimer (toujours avec WHERE)
DELETE FROM client WHERE id_client = 3;

Attention : `DELETE` sans `WHERE` efface toutes les lignes de la table. On peut aussi utiliser `TRUNCATE` pour un vidage rapide et non journalisé.

La commande SELECT est le cœur de SQL. Elle permet de filtrer (WHERE), trier (ORDER BY), grouper (GROUP BY), agréger (COUNT, SUM, AVG, MIN, MAX) et limiter (LIMIT).

-- Requête basique
SELECT nom, email FROM client WHERE date_inscription > '2025-01-01';
-- Agrégation
SELECT statut, COUNT(*) AS nb_clients, AVG(age) AS age_moyen
FROM client
GROUP BY statut
HAVING COUNT(*) > 5
ORDER BY nb_clients DESC;

ISOSET enseigne l’optimisation des requêtes SELECT (index, analyse de plans).

Les jointures sont essentielles dans une base relationnelle. Elles permettent de remonter des informations à partir de tables liées par des clés étrangères.

• INNER JOIN – seules les lignes ayant une correspondance dans les deux tables.
• LEFT JOIN – toutes les lignes de la table de gauche, avec les correspondances de la droite (NULL si absente).
• RIGHT JOIN – symétrique du LEFT JOIN.
• FULL OUTER JOIN – toutes les lignes des deux tables.
• CROSS JOIN – produit cartésien (toutes les combinaisons).

-- INNER JOIN classique
SELECT client.nom, commande.date_cmd, commande.montant
FROM client
INNER JOIN commande ON client.id_client = commande.id_client;
-- LEFT JOIN pour voir aussi les clients sans commande
SELECT client.nom, commande.date_cmd
FROM client
LEFT JOIN commande ON client.id_client = commande.id_client;

ISOSET propose des exercices progressifs sur les jointures avec des cas métier concrets (ventes, RH, logistique).

Une sous‑requête est une requête SQL imbriquée dans une autre. Les CTE (Common Table Expressions), introduites par `WITH`, améliorent la lisibilité et permettent la récursivité.

-- Sous‑requête dans WHERE
SELECT nom FROM client 
WHERE id_client IN (SELECT DISTINCT id_client FROM commande);
-- Sous‑requête dans SELECT (scalaire)
SELECT client.nom, 
       (SELECT COUNT(*) FROM commande WHERE commande.id_client = client.id_client) AS nb_commandes
FROM client;
-- CTE (WITH)
WITH clients_actifs AS (
    SELECT id_client FROM commande WHERE date_cmd > CURRENT_DATE - INTERVAL '30 days'
)
SELECT nom FROM client WHERE id_client IN (SELECT id_client FROM clients_actifs);

Les sous‑requêtes corrélées et les CTE récursives sont des fonctionnalités avancées abordées dans les formations ISOSET.

Sans index, une requête parcourt toute la table (scan). Les index B‑Tree (les plus courants) permettent de trouver une ligne en O(log n). On indexe généralement les colonnes utilisées dans `WHERE`, `JOIN`, `ORDER BY`.

• Index simple – `CREATE INDEX idx_nom ON client(nom);`
• Index composite – `CREATE INDEX idx_nom_prenom ON client(nom, prenom);` (respecter l’ordre des colonnes).
• Index unique – garantit l’unicité (comme la clé primaire).
• Analyse du plan d’exécution – `EXPLAIN (ANALYZE) SELECT …` pour comprendre les choix de l’optimiseur.

-- Plan d’exécution (PostgreSQL)
EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM commande WHERE id_client = 42;

Un mauvais usage des index (ou leur absence) est la première cause de lenteur des bases de données. ISOSET forme à l’optimisation des performances SQL.

Une transaction regroupe plusieurs instructions SQL qui seront exécutées de manière atomique. Si une erreur survient, tout est annulé (ROLLBACK). Une transaction validée (COMMIT) est définitive.

-- Exemple de transaction bancaire
BEGIN;
UPDATE compte SET solde = solde - 100 WHERE id_compte = 1;
UPDATE compte SET solde = solde + 100 WHERE id_compte = 2;
COMMIT;
-- En cas d’erreur
ROLLBACK;

Les niveaux d’isolation (READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE) gèrent les phénomènes de lecture concurrente. ISOSET apprend à choisir le bon niveau d’isolation selon les besoins métier.

• Nommer explicitement les colonnes – éviter `SELECT *` en production.
• Utiliser des alias – pour améliorer la lisibilité des colonnes calculées ou des tables jointes.
• Éviter les fonctions sur les colonnes indexées – `WHERE DATE(date) = ‘2025-01-01’` ne peut pas utiliser l’index ; préférer `WHERE date BETWEEN …`.
• Préférer les jointures aux sous‑requêtes corrélées – souvent plus efficaces.
• Limiter les résultats en développement – utiliser `LIMIT` (ou `FETCH FIRST`) pour les tests.
• Commenter les requêtes complexes – expliquer la logique métier.

Les témoignages d’anciens élèves d’ISOSET soulignent l’importance de maîtriser SQL : *« Après la formation, je suis passé de requêtes basiques à des analyse complexes avec CTE et fenêtrage. Aujourd’hui, je suis data analyst. »*