SQL & Databases

Introduction aux bases de données relationnelles

Comprendre tables, lignes, colonnes, clés, relations et grain avant d'écrire des requêtes fiables.

Environnement SQL : SQLite, PostgreSQL et inspection de schéma

Installer un environnement léger, ouvrir une base, explorer les tables et documenter le schéma avant de requêter.

SELECT & FROM : lire une table proprement

Lire uniquement les colonnes utiles, nommer les sorties et éviter le réflexe SELECT *.

WHERE : filtrer sans changer le grain

Écrire des filtres reproductibles, gérer NULL et combiner les conditions sans ambiguïté.

ORDER BY & LIMIT : résultats stables

Trier, limiter et paginer un résultat avec un ordre déterministe.

Fonctions d'agrégation : COUNT, SUM, AVG, MIN, MAX

Calculer des métriques correctes en distinguant lignes, valeurs non NULL et conventions métier.

GROUP BY : agréger au bon grain

Utiliser GROUP BY, HAVING et les alias sans mélanger les grains.

HAVING : filtrer après agrégation

Comprendre la différence entre WHERE et HAVING pour filtrer les lignes avant agrégation ou les groupes après agrégation.

Agrégations analytiques et grain de mesure

Produire des KPI analytiques sans confondre commande, ligne de commande et client.

Window functions : OVER, PARTITION BY et classements

Utiliser ROW_NUMBER, RANK, SUM OVER et PARTITION BY pour analyser sans réduire le nombre de lignes.

INSERT INTO : créer sans casser le schéma

Insérer des données en nommant les colonnes et en respectant les contraintes.

INSERT robuste et idempotence

Rendre les insertions robustes face aux relectures, doublons et flux concurrents.

UPDATE : modifier avec garde-fous

Modifier une table avec WHERE, prévisualisation et contrôle de périmètre.

UPDATE sûr : périmètre, état et audit

Encadrer les updates sensibles avec état courant, version, audit et comptage préalable.

DELETE : supprimer avec preuves et limites

Supprimer des lignes uniquement quand le périmètre, l'audit et la réversibilité sont maîtrisés.

DELETE, rétention et soft delete

Choisir entre suppression physique, soft delete, anonymisation et rétention réglementaire.

Transactions : COMMIT, ROLLBACK, isolation et concurrence

Encadrer les écritures sensibles avec BEGIN, COMMIT, ROLLBACK et comprendre les risques de concurrence.

Clés primaires et étrangères

Définir l'identité, l'unicité et l'intégrité référentielle d'un modèle relationnel.

Contraintes, normalisation et invariants

Utiliser NOT NULL, UNIQUE, CHECK, FK et normalisation pour protéger les invariants.

Modélisation relationnelle avancée

Modéliser un cas e-commerce avec tables de faits, dimensions, cardinalités et contraintes.

Types SQL, dates, NULL et conversions

Choisir les types adaptés, filtrer les dates sans piège et comprendre la logique à trois valeurs de NULL.

DDL : CREATE, ALTER, DROP et changements de schéma

Créer ou faire évoluer une table sans casser les consommateurs, avec migration, rollback et communication.

JOIN : relier les tables sans perdre le grain

Choisir INNER, LEFT et anti-join selon la question métier et le grain de sortie.

Jointures avancées : fan-out et anti-join

Diagnostiquer le fan-out, écrire des anti-joins et éviter les doublons invisibles.

Sous-requêtes : IN, EXISTS et requêtes corrélées

Utiliser les sous-requêtes pour exprimer une condition d'existence, éviter les doublons et écrire des anti-joins.

CTE avec WITH : lisibilité, étapes et réutilisation

Découper une requête complexe en étapes nommées avec WITH sans perdre la traçabilité du grain.

Index et performance

Comprendre quand un index aide, quand il coûte et comment le justifier par une requête.

EXPLAIN et stratégie d'index

Lire un plan EXPLAIN, relier index et requête observée, éviter les index cosmétiques.

Pagination déterministe et curseurs

Remplacer les offsets profonds par une pagination stable fondée sur un curseur.

Optimiser une requête sans cargo cult

Diagnostiquer une requête lente avec hypothèse, mesure, index pertinent et preuve avant/après.

Vues, vues matérialisées et pré-agrégats

Créer des vues pour stabiliser une logique métier et comprendre quand matérialiser un résultat.

SELECT avancé : expressions, CASE et COALESCE

Créer des colonnes calculées, segmenter avec CASE et rendre les exports lisibles.

Filtres avancés : NULL, IN, BETWEEN, LIKE

Filtrer proprement les périodes, les valeurs absentes et les conditions composées.

SQL + Python : sqlite3, SQLAlchemy et pandas

Lire et écrire des données depuis Python, paramétrer les requêtes et éviter l'injection SQL.

Qualité de données et tests SQL

Transformer les invariants métier en tests SQL : unicité, non-nullité, relations, bornes et fraîcheur.

dbt : modèles SQL, sources, tests et documentation

Comprendre l'analytics engineering avec dbt : modèles SELECT, dépendances, tests et documentation.

Sécurité SQL : injection, secrets et permissions

Écrire des requêtes paramétrées, limiter les droits et protéger secrets, PII et opérations destructives.

Backups, migrations et gouvernance des changements

Préparer les migrations, sauvegardes, restaurations et plans de rollback avant une modification risquée.

Patterns d'entretien SQL et communication de solution

Résoudre un cas SQL en expliquant grain, hypothèses, requête, validations et limites.

Capstone SQL : base e-commerce auditable

Concevoir, requêter, auditer et défendre une base e-commerce complète.