Proposé par Edgar F. Codd dans les années 1970, le modèle relationnel organise les données en tables (relations) composées de lignes (tuples) et de colonnes (attributs). Chaque table possède une clé primaire (identifiant unique) et peut être reliée à d’autres tables via des clés étrangères. Ce modèle garantit l’intégrité et l’absence de redondance grâce aux formes normales.

• Tables – représentent des entités (client, produit, commande).
• Clé primaire (PK) – colonne (ou combinaison) qui identifie de manière unique chaque ligne.
• Clé étrangère (FK) – colonne qui référence la clé primaire d’une autre table, assurant la cohérence référentielle.
• Contraintes – NOT NULL, UNIQUE, CHECK, DEFAULT pour garantir l’intégrité des données.

# Création de tables avec clés primaire et étrangère
CREATE TABLE client (
    id_client INT PRIMARY KEY,
    nom VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE
);
CREATE TABLE commande (
    id_cmd INT PRIMARY KEY,
    date_cmd DATE,
    id_client INT,
    FOREIGN KEY (id_client) REFERENCES client(id_client)
);

ISOSET forme à la conception de bases relationnelles normalisées, de la modélisation à l’implémentation.

SQL (Structured Query Language) est le langage standard pour interagir avec les bases relationnelles. Il se divise en plusieurs sous-langages : DDL (définition), DML (manipulation), DCL (contrôle) et DQL (interrogation).

# Exemples de DML
SELECT nom, email FROM client WHERE ville = 'Paris' ORDER BY nom;
INSERT INTO client (id_client, nom, email) VALUES (1, 'Dupont', 'dupont@mail.com');
UPDATE client SET email = 'nouveau@mail.com' WHERE id_client = 1;
DELETE FROM commande WHERE date_cmd < '2024-01-01';

Les jointures permettent de combiner des lignes de deux ou plusieurs tables en fonction d’une condition de correspondance (généralement la clé étrangère).

• INNER JOIN – retourne uniquement les lignes ayant une correspondance dans les deux tables.
• LEFT JOIN (ou RIGHT JOIN) – retourne toutes les lignes de la table de gauche, avec les correspondances de la table de droite (NULL si absente).
• FULL OUTER JOIN – retourne toutes les lignes des deux tables, avec NULL de chaque côté quand il n’y a pas de correspondance.
• CROSS JOIN – produit cartésien (toutes les combinaisons). À utiliser avec précaution.

# INNER JOIN entre client et commande
SELECT client.nom, commande.date_cmd
FROM client
INNER JOIN commande ON client.id_client = commande.id_client;
# LEFT JOIN pour voir tous les clients, même sans commande
SELECT client.nom, commande.date_cmd
FROM client
LEFT JOIN commande ON client.id_client = commande.id_client;

ISOSET propose des exercices pratiques sur les jointures avec des cas métier concrets (analyse de ventes, CRM).

Une sous-requête est une requête SQL imbriquée dans une autre. Elle peut apparaître dans les clauses SELECT, FROM, WHERE, HAVING.

• Sous-requête scalaire – retourne une seule valeur (ex: MAX(prix)).
• Sous-requête de ligne – retourne une seule ligne de plusieurs colonnes.
• Sous-requête de table – retourne un ensemble de lignes utilisé comme table dérivée dans la clause FROM.
• Opérateurs associés – IN, EXISTS, ANY, ALL, comparaisons (=, >, <).

# Clients qui ont passé au moins une commande (sous-requête avec IN)
SELECT nom FROM client WHERE id_client IN (SELECT DISTINCT id_client FROM commande);
# Sous-requête corrélée avec EXISTS
SELECT nom FROM client c WHERE EXISTS (SELECT 1 FROM commande cmd WHERE cmd.id_client = c.id_client);

Une requête mal écrite peut prendre des minutes sur des millions de lignes. L’optimisation vise à réduire les coûts d’exécution (lecture disque, CPU, mémoire).

• Indexation – créer des index sur les colonnes utilisées dans WHERE, JOIN, ORDER BY. L’index B-Tree est le plus courant.
• Analyse du plan d’exécution – utiliser EXPLAIN (ou EXPLAIN ANALYZE) pour comprendre comment le SGBD exécute la requête.
• Éviter SELECT * – ne sélectionner que les colonnes nécessaires pour réduire les transferts.
• Limiter les sous-requêtes corrélées – souvent plus lentes qu’une jointure ou une requête avec GROUP BY.
• Partitionnement – diviser une très grande table en morceaux (par date, par région).
• Mise à jour des statistiques – les SGBD utilisent des statistiques sur les colonnes pour choisir le plan optimal.

# Création d’un index sur une colonne fréquemment utilisée dans WHERE
CREATE INDEX idx_client_nom ON client(nom);
# Analyse du plan d’exécution (PostgreSQL)
EXPLAIN ANALYZE SELECT * FROM commande WHERE id_client = 123;

ISOSET enseigne l’optimisation des requêtes sur des bases de taille réelle, avec des exercices de tuning et d’analyse de plans.

L’administration (DBA) couvre la gestion des utilisateurs, des sauvegardes, de la sécurité, de la performance et de la haute disponibilité.

• Gestion des utilisateurs et privilèges – GRANT, REVOKE, création de rôles. Sécurité fine par objet.
• Sauvegarde et restauration – backups logiques (dump SQL) ou physiques (copie des fichiers). Stratégies full + incrémentales.
• Surveillance des performances – monitoring des requêtes lentes, utilisation CPU/RAM, espace disque.
• Haute disponibilité (HA) – réplication maître-esclave, clusters (Patroni, Galera), bascule automatique.
• Nettoyage et maintenance – VACUUM (PostgreSQL), OPTIMIZE TABLE (MySQL), reconstruction d’index.
• Sécurité – chiffrement au repos et en transit, audits de connexion, mise à jour des patches.

# Gestion des droits (MySQL)
CREATE USER 'app_user'@'localhost' IDENTIFIED BY 'strong_password';
GRANT SELECT, INSERT, UPDATE ON ma_base.* TO 'app_user'@'localhost';
# Sauvegarde avec pg_dump (PostgreSQL)
pg_dump -U admin -F c -b -v -f "backup_20250421.dump" ma_base

ISOSET propose des formations à l’administration SQL pour les professionnels et le grand public, avec des labs sur PostgreSQL, MySQL et SQL Server.

• Nommage clair – utiliser des noms explicites (snake_case) pour tables et colonnes.
• Commenter les requêtes complexes – expliquer le raisonnement derrière une sous-requête ou une jointure non triviale.
• Utiliser des alias – pour améliorer la lisibilité des colonnes calculées ou des tables jointes.
• Éviter les fonctions sur les colonnes indexées dans WHERE – WHERE YEAR(date) = 2025 ne peut pas utiliser l’index ; préférer WHERE date BETWEEN '2025-01-01' AND '2025-12-31'.
• Préférer les jointures aux sous-requêtes corrélées – souvent plus performant.
• Tester avec des jeux de données réalistes – pas seulement sur des lignes d’exemple.

• PostgreSQL – open source, riche en fonctionnalités (JSON, recherche plein texte, extensions). Idéal pour les applications complexes.
• MySQL / MariaDB – très répandu, simple, bonnes performances en lecture. Utilisé par de nombreux sites web (WordPress, etc.).
• Microsoft SQL Server – intégration avec l’écosystème Microsoft, outils BI puissants (SSIS, SSRS).
• Oracle Database – solution historique pour les grandes entreprises, très robuste mais coûteuse.
• SQLite – base embarquée, sans serveur, parfaite pour applications mobiles ou petits outils.

ISOSET propose des initiations à SQL sur SQLite pour les jeunes, afin de découvrir la manipulation de données en douceur.

Même dans le monde du Big Data, SQL reste incontournable via des moteurs de requête distribués :

• Apache Hive – permet d’interroger des données Hadoop avec une syntaxe SQL-like (HiveQL).
• Presto / Trino – moteur de requêtes SQL distribué pour interroger plusieurs sources (S3, Hive, Kafka, etc.).
• Google BigQuery, Amazon Athena, Snowflake – entrepôts de données cloud avec SQL standard.

La maîtrise de SQL est donc un passeport pour l’analyse de données à grande échelle.

Les témoignages d’anciens élèves d’ISOSET soulignent l’efficacité de la formation : *« Après le module SQL, j’ai pu créer des requêtes complexes et optimiser des rapports qui prenaient 10 minutes pour s’exécuter. Maintenant, c’est instantané. »*