Guide pratique · E-commerce · SaaS · Finance · Lecture : ~14 min Teste ton niveau sur modai-lab.com/test-sql/


Pourquoi ce guide existe

« Quels sont les 4 types de bases de donnĂ©es ? » C'est une question qui tombe en entretien data, en rĂ©union d'archi, ou au moment oĂč un dev te dit « les events sont dans Mongo, dĂ©brouille-toi ».

Le problÚme : la plupart des gens récitent une liste (« relationnel, document, clé-valeur, graphe ») sans savoir ce qui change concrÚtement pour celui qui doit interroger la donnée. Résultat :

  • Tu essaies de faire un JOIN mental sur des documents JSON imbriquĂ©s et tu dupliques tes lignes

  • Tu cherches Ă  faire des agrĂ©gats sur un cache clĂ©-valeur qui n'a jamais Ă©tĂ© conçu pour ça

  • Tu Ă©cris 4 self-joins pour remonter une chaĂźne de parrainage alors qu'un graphe (ou un CTE rĂ©cursif) le fait en 10 lignes

  • Tu mets tout dans Postgres « parce que c'est du SQL » et ta table de sessions explose

Ce guide couvre :

  • Les 4 grandes familles : relationnelle, document, clĂ©-valeur, graphe

  • Pour chacune : comment la donnĂ©e est stockĂ©e, comment on l'interroge, et ce que ça implique cĂŽtĂ© SQL

  • Les erreurs classiques du junior qui dĂ©barque sur chaque type (❌ / ✅)

  • Un cas business chiffrĂ© par famille

  • Un bonus sur le colonnaire analytique (BigQuery, Snowflake), la base que tu utilises sans doute le plus

  • Une grille de dĂ©cision pour choisir, un prompt Claude d'audit et une checklist


đŸ§Ș Calibre ton niveau avant de commencer

Tu sais modĂ©liser une relation 1-N avec une clĂ© Ă©trangĂšre ? Extraire un champ d'une colonne JSON ? Écrire un CTE rĂ©cursif ? Si tu hĂ©sites sur l'une des trois, ce guide va te servir. Fais le test en 5 minutes.

👉 Faire le test sur modai-lab.com/test-sql/

_Résultat en direct · Niveau calibré · Parcours personnalisé_


Vue d'ensemble : les 4 familles en un coup d'Ɠil

Type

Unité de stockage

Langage de requĂȘte

Exemples

Point fort

Relationnelle

Ligne dans une table

SQL

PostgreSQL, MySQL, SQL Server, Oracle

Cohérence, jointures, transactions

Document

Document JSON/BSON

API ou langage propre (MQL)

MongoDB, Firestore, Couchbase

Schéma flexible, objets imbriqués

Clé-valeur

Paire clĂ© → valeur

GET / SET

Redis, DynamoDB, Memcached

Latence ultra-faible

Graphe

NƓuds + relations

Cypher, Gremlin

Neo4j, Neptune, Memgraph

Parcours de relations profondes

La vraie question n'est pas « laquelle est la meilleure » mais : quelle forme ont tes requĂȘtes ?

  • Tu croises plusieurs entitĂ©s et tu agrĂšges → relationnel

  • Tu lis/Ă©cris un objet complet d'un coup → document

  • Tu lis une valeur Ă  partir d'une clĂ© connue, des milliers de fois par seconde → clĂ©-valeur

  • Tu suis des chaĂźnes de relations de longueur variable → graphe


PARTIE 1 — Les bases relationnelles : le socle du SQL

Le mécanisme

Une base relationnelle stocke la donnĂ©e en tables (lignes × colonnes) avec un schĂ©ma fixe dĂ©clarĂ© Ă  l'avance. Les tables sont reliĂ©es par des clĂ©s :

  • ClĂ© primaire (PRIMARY KEY) : identifie chaque ligne de façon unique

  • ClĂ© Ă©trangĂšre (FOREIGN KEY) : rĂ©fĂ©rence la clĂ© primaire d'une autre table

Sous le capot, le moteur garantit les propriétés ACID :

  • AtomicitĂ© : une transaction passe entiĂšrement ou pas du tout

  • CohĂ©rence : les contraintes (NOT NULL, FK, CHECK) sont toujours respectĂ©es

  • Isolation : deux transactions concurrentes ne se marchent pas dessus

  • DurabilitĂ© : une fois commitĂ©e, la donnĂ©e survit Ă  un crash

C'est pour ça que les banques, les ERP et les back-offices e-commerce tournent sur du relationnel : un virement ne peut pas ĂȘtre « Ă  moitiĂ© passĂ© ».

La normalisation consiste à découper la donnée pour qu'une information n'existe qu'à un seul endroit. Le prix à payer : il faut des jointures pour la reconstituer.

Erreur classique : la table « fourre-tout »

-- ❌ Tout dans une seule table, infos client rĂ©pĂ©tĂ©es Ă  chaque commande
CREATE TABLE orders_flat (
order_id INT,
client_nom VARCHAR(),
client_email VARCHAR(),
client_ville VARCHAR(),
produit VARCHAR(),
montant DECIMAL(,),
created_at TIMESTAMP
);
 
-- Données :
-- order_id | client_nom | client_email | client_ville | produit | montant
-- 1001 | Julie Martin | julie@mail.fr | Lyon | Casque | 89.00
-- 1002 | Julie Martin | julie@mail.fr | Lyon | Clavier | 59.00
-- 1003 | Julie Martin | julie.m@mail.fr | Paris | Souris | 29.00
--
-- ProblÚme : Julie a déménagé et changé d'email.
-- Laquelle des 3 lignes dit la vérité ? Aucune contrainte ne protÚge la cohérence.
-- COUNT(DISTINCT client_email) te donnera 2 clients au lieu de 1.
4-types-bases-de-donnees · 01
-- ✅ ModĂšle normalisĂ© : chaque info vit Ă  un seul endroit
CREATE TABLE users (
user_id INT PRIMARY KEY,
nom VARCHAR() NOT NULL,
email VARCHAR() UNIQUE NOT NULL,
ville VARCHAR()
);
 
CREATE TABLE orders (
order_id INT PRIMARY KEY,
user_id INT NOT NULL REFERENCES users(user_id), -- clé étrangÚre
montant DECIMAL(,) NOT NULL CHECK (montant >= ),
statut VARCHAR() NOT NULL,
created_at TIMESTAMP NOT NULL
);
 
-- Julie dĂ©mĂ©nage → 1 seul UPDATE, toutes ses commandes sont Ă  jour
UPDATE users SET ville = 'Paris', email = 'julie.m@mail.fr' WHERE user_id = ;
 
-- Gain : impossible de créer une commande pour un client inexistant,
-- impossible d'avoir deux emails diffĂ©rents pour la mĂȘme personne.
4-types-bases-de-donnees · 02

Cas business : CA par ville sur un e-commerce

Contexte : boutique en ligne, 18 400 clients, 61 200 commandes sur 2026. Le directeur commercial veut le CA livré par ville au T3.

SELECT
u.ville,
COUNT(DISTINCT u.user_id) AS nb_clients,
COUNT(o.order_id) AS nb_commandes,
SUM(o.montant) AS ca_ttc,
ROUND(SUM(o.montant) / COUNT(o.order_id), ) AS panier_moyen
FROM orders o
JOIN users u ON u.user_id = o.user_id
WHERE o.statut = 'livree'
AND o.created_at >= '2026-07-01'
AND o.created_at < '2026-10-01'
GROUP BY u.ville
ORDER BY ca_ttc DESC
LIMIT ;
 
-- Résultat :
-- ville | nb_clients | nb_commandes | ca_ttc | panier_moyen
-- Paris | 3 120 | 5 840 | 412 380.00 | 70.61
-- Lyon | 1 410 | 2 470 | 168 950.00 | 68.40
-- Marseille | 1 180 | 1 990 | 129 340.00 | 64.99
-- Toulouse | 960 | 1 610 | 108 870.00 | 67.62
-- Lille | 820 | 1 380 | 91 080.00 | 66.00
4-types-bases-de-donnees · 03

Cette requĂȘte est triviale en relationnel. Garde-la en tĂȘte : c'est exactement celle qui devient pĂ©nible sur les trois autres familles.

Quand l'utiliser / quand l'éviter

  • ✅ DonnĂ©es structurĂ©es, relations nombreuses, besoin de transactions (commandes, paiements, comptes, RH)

  • ✅ Reporting ad hoc : n'importe quelle question peut ĂȘtre posĂ©e aprĂšs coup

  • ❌ SchĂ©ma qui change toutes les semaines (attributs produits trĂšs hĂ©tĂ©rogĂšnes)

  • ❌ Millions de lectures/s sur une clĂ© simple (sessions, compteurs temps rĂ©el)

đŸ§Ș MaĂźtrise les jointures sur des schĂ©mas rĂ©els

Sur Modai Lab, tu travailles sur des schémas relationnels de production (e-commerce, SaaS, fintech) avec plusieurs tables à relier, pas sur une table employees de 10 lignes.

👉 Pratiquer sur modai-lab.com

_Schémas multi-tables · Cas business réels · Correction IA détaillée_


PARTIE 2 — Les bases document : JSON au cƓur du modùle

Le mécanisme

Une base document (MongoDB, Firestore, Couchbase) stocke des documents autonomes, généralement en JSON (ou BSON, sa version binaire). Chaque document peut avoir une structure différente : pas de schéma imposé.

Au lieu de découper la donnée en tables, on imbrique ce qui est lu ensemble :

{
"_id": "ord_1001",
"created_at": "2026-09-14T10:22:00Z",
"statut": "livree",
"client": { "user_id": 42, "nom": "Julie Martin", "ville": "Lyon" },
"lignes": [
{ "sku": "CAS-01", "produit": "Casque", "qte": 1, "prix": 89.00 },
{ "sku": "CAB-07", "produit": "CĂąble USB-C", "qte": 2, "prix": 9.50 }
],
"montant": 108.00
}
4-types-bases-de-donnees · 04

Avantage : l'application lit toute la commande en une seule lecture, sans jointure. Inconvénient : le nom et la ville du client sont copiés dans chaque commande (dénormalisation). Si Julie déménage, ses anciennes commandes gardent « Lyon ». Parfois c'est voulu (adresse au moment de la commande), parfois c'est un bug.

CĂŽtĂ© requĂȘte, MongoDB a son propre langage :

// Commandes livrées à Lyon
db.orders.find({ "client.ville": "Lyon", "statut": "livree" })
 
// CA par ville (pipeline d'agrégation)
db.orders.aggregate([
{ $match: { statut: "livree" } },
{ $group: { _id: "$client.ville", ca: { $sum: "$montant" } } },
{ $sort: { ca: -1 } }
])
4-types-bases-de-donnees · 05

Ce qui te concerne en tant que data analyst : ces documents finissent presque toujours dans ton warehouse sous forme de colonne JSON. Et c'est lĂ  que les erreurs commencent.

Erreur classique : aplatir un tableau sans réfléchir

Les données Mongo ont été chargées dans PostgreSQL, dans une table orders_raw (order_id, doc JSONB).

-- ❌ On « explose » les lignes de commande puis on somme le montant total
SELECT
doc->'client'->>'ville' AS ville,
SUM((doc->>'montant')::numeric) AS ca
FROM orders_raw,
jsonb_array_elements(doc->'lignes') AS ligne -- 1 ligne SQL par article
WHERE doc->>'statut' = 'livree'
GROUP BY ;
 
-- Commande ord_1001 : 2 articles → la commande apparaüt 2 fois
-- montant = 108.00 comptĂ© 2 fois → 216.00
-- Sur le T3, le CA de Lyon passe de 168 950 € à 371 690 € (panier moyen 2,2 articles).
-- Personne ne s'en rend compte avant la réunion avec le CFO.
4-types-bases-de-donnees · 06
-- ✅ On agrùge au bon grain : soit le document, soit la ligne d'article
-- Option A : CA au niveau commande, sans exploser le tableau
SELECT
doc->'client'->>'ville' AS ville,
SUM((doc->>'montant')::numeric) AS ca
FROM orders_raw
WHERE doc->>'statut' = 'livree'
GROUP BY ;
 
-- Option B : CA au niveau article, en sommant ce qui est au grain article
SELECT
ligne->>'produit' AS produit,
SUM((ligne->>'qte')::int * (ligne->>'prix')::numeric) AS ca_produit
FROM orders_raw,
jsonb_array_elements(doc->'lignes') AS ligne
WHERE doc->>'statut' = 'livree'
GROUP BY
ORDER BY ca_produit DESC;
 
-- Gain : chaque métrique est sommée à son grain naturel. Zéro double comptage.
4-types-bases-de-donnees · 07

RĂšgle Ă  retenir : dĂšs que tu dĂ©-imbriques un tableau (jsonb_array_elements, UNNEST, LATERAL FLATTEN), le grain de ta requĂȘte change. Ne somme plus jamais une valeur du niveau parent aprĂšs ça.

Cas business : catalogue produit d'une marketplace

Contexte : marketplace de 120 000 produits. Un smartphone a « RAM », « stockage », « taille d'écran » ; un t-shirt a « taille », « matiÚre », « coupe ». Impossible d'avoir une colonne par attribut (il y en a 900+). Les attributs sont stockés en JSON.

-- Table products(product_id, categorie, prix, attributs JSONB)
-- Exemple de ligne :
-- 5521 | smartphone | 699.00 | {"ram_go": 8, "stockage_go": 256, "couleur": "noir"}
-- 8803 | tshirt | 24.90 | {"taille": "M", "matiere": "coton bio"}
 
-- Prix moyen des smartphones par capacité de stockage
SELECT
(attributs->>'stockage_go')::int AS stockage_go,
COUNT(*) AS nb_modeles,
ROUND(AVG(prix), ) AS prix_moyen
FROM products
WHERE categorie = 'smartphone'
AND attributs ? 'stockage_go' -- la clé existe dans le JSON
GROUP BY
ORDER BY ;
 
-- stockage_go | nb_modeles | prix_moyen
-- 64 | 412 | 189.40
-- 128 | 1 380 | 342.10
-- 256 | 1 120 | 611.75
-- 512 | 290 | 1 049.90
4-types-bases-de-donnees · 08

C'est le modĂšle « hybride » que beaucoup d'Ă©quipes adoptent : relationnel pour le cƓur (prix, catĂ©gorie), JSON pour la partie variable.

Quand l'utiliser / quand l'éviter

  • ✅ Objets lus/Ă©crits d'un bloc (profil utilisateur, panier, contenu CMS)

  • ✅ SchĂ©ma qui Ă©volue vite, attributs hĂ©tĂ©rogĂšnes

  • ❌ Beaucoup de relations croisĂ©es entre entitĂ©s (tu finis par recoder les jointures dans l'appli)

  • ❌ Reporting transverse frĂ©quent (passe par un warehouse)

đŸ§Ș Teste ta maĂźtrise du JSON en SQL

Extraire un champ, dé-imbriquer un tableau sans doubler ton CA, filtrer sur une clé optionnelle : ce sont des compétences testées dans les entretiens data actuels.

👉 Faire le test sur modai-lab.com/test-sql/

_5 minutes · Niveau calibré · Points faibles identifiés_


PARTIE 3 — Les bases clĂ©-valeur : la vitesse avant tout

Le mécanisme

C'est le modÚle le plus simple : un gigantesque dictionnaire. Une clé unique pointe vers une valeur opaque (une chaßne, un JSON, un compteur
).

session:8f3a2c → {"user_id": 42, "panier": [5521, 8803], "exp": 1730900000}
rate_limit:ip:81.2.69.1 → 37
feature_flag:new_checkout → "on"
4-types-bases-de-donnees · 09

Les opérations de base sont minimalistes :

SET session:8f3a2c '{"user_id":42}' EX 1800 -- écrit, expire dans 30 min
GET session:8f3a2c -- lit
INCR rate_limit:ip:81.2.69.1 -- incrémente atomiquement
DEL session:8f3a2c -- supprime
4-types-bases-de-donnees · 10

Pourquoi c'est si rapide : la base n'a aucune requĂȘte Ă  planifier. Elle hache la clĂ©, va directement Ă  l'emplacement, renvoie la valeur. Redis, qui travaille en mĂ©moire, rĂ©pond en moins d'une milliseconde. DynamoDB tient des millions de requĂȘtes par seconde.

Le revers : tu ne peux pas demander « toutes les sessions des utilisateurs lyonnais » ou « la somme des paniers ». La base ne connaßt que les clés. Pas de WHERE sur la valeur, pas de GROUP BY, pas de JOIN.

Erreur classique : vouloir faire de l'analytique sur le cache

-- ❌ « Je veux le nombre de paniers actifs par ville, je vais scanner Redis »
KEYS session:* -- parcourt TOUTES les clés (bloque Redis en prod)
-- puis GET sur chacune des 240 000 sessions, parsing JSON cÎté script,
-- agrégation en Python

--
-- Résultat : Redis gÚle 4 secondes en pleine journée,
-- le site renvoie des erreurs 500, l'équipe infra te cherche.
4-types-bases-de-donnees · 11
-- ✅ La base clĂ©-valeur sert l'application ; l'analyse se fait ailleurs.
-- Les événements de panier sont envoyés en continu vers le warehouse
-- (table cart_events) et on interroge celle-ci en SQL.
 
SELECT
u.ville,
COUNT(DISTINCT c.session_id) AS paniers_actifs
FROM cart_events c
JOIN users u ON u.user_id = c.user_id
WHERE c.event_ts >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL MINUTE)
AND c.event_type = 'add_to_cart'
GROUP BY u.ville
ORDER BY paniers_actifs DESC;
 
-- Gain : zĂ©ro impact sur la prod, une vraie requĂȘte SQL rejouable,
-- et tu peux croiser avec n'importe quelle autre table.
4-types-bases-de-donnees · 12

RÚgle : une base clé-valeur est une source opérationnelle, jamais une source de reporting. Si tu as besoin de la donnée, demande qu'elle soit exportée.

Cas business : rate limiting d'une API SaaS

Contexte : un SaaS B2B expose une API publique. Chaque client a droit Ă  1 000 appels par minute. 3 200 clients, pic Ă  45 000 requĂȘtes/s.

Le contrĂŽle se fait dans Redis, Ă  chaque appel :

-- Clé = client + minute courante
INCR quota:client_318:2026-11-06T10:12 → 1 (premier appel de la minute)
EXPIRE quota:client_318:2026-11-06T10:12 60
...
INCR quota:client_318:2026-11-06T10:12 → 1001 → l'API renvoie 429 Too Many Requests
4-types-bases-de-donnees · 13

Faire ça dans Postgres avec un UPDATE quotas SET n = n + 1 Ă  45 000 requĂȘtes/s crĂ©erait des verrous en cascade. Redis le fait en mĂ©moire, atomiquement.

Et cÎté data, l'équipe produit veut savoir qui atteint ses limites. Les rejets 429 sont loggés dans le warehouse :

SELECT
client_id,
COUNT(*) AS nb_rejets_429,
COUNT(DISTINCT DATE(event_ts)) AS jours_concernes
FROM api_logs
WHERE status_code =
AND event_ts >= '2026-10-01'
GROUP BY client_id
HAVING COUNT(*) >
ORDER BY nb_rejets_429 DESC;
 
-- client_id | nb_rejets_429 | jours_concernes
-- 318 | 14 820 | 22
-- 1044 | 6 310 | 9
-- 77 | 2 140 | 31
-- → 3 clients à contacter pour un upsell vers le plan Enterprise.
4-types-bases-de-donnees · 14

Quand l'utiliser / quand l'éviter

  • ✅ Sessions, cache, paniers temporaires, compteurs, feature flags, files d'attente

  • ✅ AccĂšs par clĂ© connue, latence critique

  • ❌ Toute question qui commence par « combien », « lesquels », « par segment »

  • ❌ DonnĂ©e qui doit ĂȘtre cohĂ©rente avec d'autres entitĂ©s

đŸ§Ș EntraĂźne-toi Ă  exploiter les logs applicatifs

Les données issues des systÚmes opérationnels (logs API, events, sessions) sont le quotidien du data analyst. Sur Modai Lab, tu les analyses sur des jeux de données réalistes.

👉 Pratiquer sur modai-lab.com

_Datasets de production · HAVING et agrégats · Feedback immédiat_


PARTIE 4 — Les bases graphe : quand les relations sont la donnĂ©e

Le mécanisme

Une base graphe (Neo4j, Amazon Neptune, Memgraph) stocke :

  • des nƓuds (un utilisateur, un compte bancaire, un produit)

  • des relations typĂ©es et orientĂ©es entre eux (PARRAINE, A_VIRE_A, A_ACHETE)

  • des propriĂ©tĂ©s sur les deux (montant, date
)

La diffĂ©rence clĂ© avec le relationnel : chaque nƓud garde des pointeurs directs vers ses voisins. Suivre une relation ne coĂ»te pas un JOIN avec recherche dans un index : on « marche » de nƓud en nƓud. Plus la chaĂźne est longue, plus l'Ă©cart de performance se creuse.

Le langage le plus répandu est Cypher, qui dessine littéralement le motif recherché :

// Qui a été parrainé (directement ou indirectement, jusqu'à 3 niveaux) par Julie ?
MATCH (julie:User {user_id: 42})-[:PARRAINE*1..3]->(filleul:User)
RETURN filleul.user_id, filleul.nom
4-types-bases-de-donnees · 15

Erreur classique : empiler les self-joins

Tu n'as pas de base graphe, juste une table parrainages (parrain_id, filleul_id, created_at). On te demande tout l'arbre de parrainage d'un ambassadeur.

-- ❌ Un self-join par niveau, profondeur figĂ©e en dur
SELECT p1.filleul_id AS niv1, p2.filleul_id AS niv2, p3.filleul_id AS niv3
FROM parrainages p1
LEFT JOIN parrainages p2 ON p2.parrain_id = p1.filleul_id
LEFT JOIN parrainages p3 ON p3.parrain_id = p2.filleul_id
WHERE p1.parrain_id = ;
 
-- ProblĂšmes :
-- 1. Le niveau 4 n'existe pas pour cette requĂȘte : il est silencieusement ignorĂ©
-- 2. Le résultat est « large » (1 colonne par niveau), inutilisable pour compter
-- 3. Le volume explose : 1 ligne par chemin complet, avec des NULL partout
4-types-bases-de-donnees · 16
-- ✅ CTE rĂ©cursif : profondeur dynamique, rĂ©sultat « long », exploitable
WITH RECURSIVE arbre AS (
-- Ancre : les filleuls directs
SELECT filleul_id, AS niveau
FROM parrainages
WHERE parrain_id =
 
UNION ALL
 
-- Récursion : les filleuls des filleuls
SELECT p.filleul_id, a.niveau +
FROM parrainages p
JOIN arbre a ON p.parrain_id = a.filleul_id
WHERE a.niveau < -- garde-fou contre les cycles
)
SELECT niveau, COUNT(*) AS nb_filleuls
FROM arbre
GROUP BY niveau
ORDER BY niveau;
 
-- niveau | nb_filleuls
-- 1 | 14
-- 2 | 61
-- 3 | 188
-- 4 | 402
-- Gain : tous les niveaux remontent, sans connaĂźtre la profondeur Ă  l'avance.
4-types-bases-de-donnees · 17

Le CTE rĂ©cursif, c'est le pont entre SQL et le monde graphe. Pour quelques niveaux sur quelques millions de lignes, il suffit largement. Au-delĂ  (6+ niveaux, centaines de millions de relations, requĂȘtes en temps rĂ©el), une vraie base graphe devient pertinente.

Cas business : détection de fraude en finance

Contexte : une néobanque surveille les virements. Un schéma de blanchiment classique : l'argent part d'un compte, transite par plusieurs comptes « mules » et revient à son point de départ en moins de 48 h.

En graphe, la détection tient en quelques lignes :

MATCH path = (a:Compte)-[:VIREMENT*3..5]->(a)
WHERE ALL(v IN relationships(path) WHERE v.montant > 1000)
AND last(relationships(path)).date - head(relationships(path)).date < duration('P2D')
RETURN a.compte_id, length(path) AS nb_sauts
4-types-bases-de-donnees · 18

En SQL, la version équivalente avec un CTE récursif sur virements (from_compte, to_compte, montant, created_at) :

WITH RECURSIVE chaine AS (
SELECT
from_compte AS origine,
to_compte AS courant,
created_at AS debut,
created_at AS dernier,
AS sauts,
ARRAY[from_compte] AS chemin
FROM virements
WHERE montant >
AND created_at >= NOW() - INTERVAL '7 days'
 
UNION ALL
 
SELECT
c.origine,
v.to_compte,
c.debut,
v.created_at,
c.sauts + ,
c.chemin || v.from_compte
FROM chaine c
JOIN virements v
ON v.from_compte = c.courant
AND v.created_at > c.dernier -- ordre chronologique
AND v.montant >
WHERE c.sauts <
AND NOT v.to_compte = ANY(c.chemin[:]) -- pas de boucle intermédiaire
)
SELECT DISTINCT origine AS compte_suspect, sauts
FROM chaine
WHERE courant = origine
AND sauts >=
AND dernier - debut < INTERVAL '48 hours';
 
-- compte_suspect | sauts
-- FR76-0042-8812 | 3
-- FR76-0042-1907 | 4
-- → 2 alertes transmises Ă  l'Ă©quipe conformitĂ© sur 1,8 M de virements de la semaine.
4-types-bases-de-donnees · 19

Ça marche, mais tu vois la diffĂ©rence de lisibilitĂ©. Et sur 1,8 million de virements par semaine, la version graphe rĂ©pond en millisecondes lĂ  oĂč le CTE peut prendre des minutes.

Quand l'utiliser / quand l'éviter

  • ✅ Fraude, rĂ©seaux sociaux, parrainage, recommandations (« ceux qui ont achetĂ© X »), dĂ©pendances, organigrammes

  • ✅ RequĂȘtes dont la profondeur est variable ou inconnue

  • ❌ AgrĂ©gats massifs sur des volumes (somme du CA, moyennes par segment)

  • ❌ DonnĂ©es peu reliĂ©es : tu paies la complexitĂ© sans le bĂ©nĂ©fice

đŸ§Ș Teste-toi sur les CTE rĂ©cursifs

Le CTE rĂ©cursif est l'une des notions les moins maĂźtrisĂ©es en SQL, et l'une des plus discriminantes en entretien senior. VĂ©rifie oĂč tu en es.

👉 Faire le test sur modai-lab.com/test-sql/

_Questions progressives · Du junior au senior · Résultat immédiat_


PARTIE 5 — Bonus : le colonnaire analytique (et comment choisir)

Le 5ᔉ type que tu utilises tous les jours

Dans les listes « 4 types de bases », on cite parfois les bases orientées colonnes (Cassandra, HBase) à la place du graphe. Et cÎté data, il y a surtout les entrepÎts colonnaires analytiques : BigQuery, Snowflake, Redshift, ClickHouse.

Ils parlent SQL, comme le relationnel. Mais ils stockent la donnée colonne par colonne au lieu de ligne par ligne :

Stockage en ligne (PostgreSQL) Stockage en colonne (BigQuery)
[1001, 42, 89.00, 'livree', ...] order_id : [1001, 1002, 1003, ...]
[1002, 42, 59.00, 'livree', ...] user_id : [42, 42, 17, ...]
[1003, 17, 29.00, 'annulee', ...] montant : [89.00, 59.00, 29.00, ...]
statut : ['livree', 'livree', 'annulee', ...]
4-types-bases-de-donnees · 20

ConsĂ©quence directe : une requĂȘte qui lit 2 colonnes sur 80 ne lit que ces 2 colonnes sur le disque. Parfait pour SUM, AVG, GROUP BY sur des milliards de lignes. Mauvais pour modifier une ligne prĂ©cise 10 000 fois par seconde.

C'est la distinction OLTP (transactionnel, relationnel classique) vs OLAP (analytique, colonnaire).

Erreur classique : le `SELECT *` sur un colonnaire

-- ❌ Habitude prise sur PostgreSQL, catastrophique sur BigQuery
SELECT *
FROM `analytics.events` -- 2,4 To, 85 colonnes
WHERE event_date = '2026-11-05'
LIMIT ;
 
-- Le LIMIT ne réduit PAS les octets scannés.
-- Sans partitionnement sur event_date, BigQuery lit les 85 colonnes en entier :
-- 2,4 To × ~6 $/To ≈ 15 $ pour afficher 100 lignes.
-- Lancée 20 fois par jour par 5 analystes : ~1 500 $/mois.
4-types-bases-de-donnees · 21
-- ✅ On ne sĂ©lectionne que les colonnes utiles, sur une table partitionnĂ©e
SELECT user_id, event_name, event_ts
FROM `analytics.events` -- partitionnée par event_date
WHERE event_date = '2026-11-05' -- élagage de partition
LIMIT ;
 
-- 3 colonnes × 1 partition ≈ 9 Go scannĂ©s ≈ 0,05 $
-- Gain : coût divisé par ~300, résultat identique pour l'usage visé.
4-types-bases-de-donnees · 22

La grille de décision

Ta question principale

Type recommandé

Pourquoi

« Enregistrer une commande et débiter le stock sans incohérence »

Relationnelle

Transactions ACID, contraintes

« Stocker des fiches produits aux attributs trÚs variables »

Document (ou JSON dans du relationnel)

Schéma flexible

« Retrouver la session d'un visiteur en < 1 ms »

Clé-valeur

AccÚs direct par clé, en mémoire

« Trouver les comptes reliés à un fraudeur sur 5 niveaux »

Graphe

Parcours de relations profondes

« CA mensuel par segment sur 3 ans d'historique »

Colonnaire analytique

Scan de quelques colonnes sur des milliards de lignes

Dans la vraie vie, une entreprise utilise plusieurs types en mĂȘme temps (on parle de polyglot persistence). Un e-commerce typique :

  • PostgreSQL pour les commandes et paiements

  • MongoDB pour le catalogue

  • Redis pour les paniers et sessions

  • Neo4j pour les recommandations

  • BigQuery oĂč tout converge pour l'analyse

Et le langage qui te permet d'interroger à peu prÚs tout ça une fois arrivé dans le warehouse : SQL.

đŸ§Ș Écris du SQL qui tient en production

Sur Modai Lab, tu travailles sur des volumes et des schĂ©mas rĂ©alistes, avec un feedback sur la justesse ET la façon d'Ă©crire tes requĂȘtes.

👉 Pratiquer sur modai-lab.com

_Volumes réalistes · Bonnes pratiques warehouse · Correction senior_


Erreurs classiques : le récap junior vs senior

Situation

❌ Le junior

✅ Le senior

Modélisation relationnelle

Une table plate avec les infos client répétées

Tables normalisées + clés étrangÚres

JSON dé-imbriqué

Somme le montant parent aprĂšs UNNEST

AgrÚge au grain de la donnée sommée

Besoin d'analyse sur Redis

KEYS * en prod + script Python

Demande un export vers le warehouse

Hiérarchie / parrainage

N self-joins figés

CTE récursif avec garde-fou

RequĂȘte exploratoire sur BigQuery

SELECT * ... LIMIT 100

Colonnes ciblées + filtre de partition

Question d'entretien « 4 types »

Récite une liste

Explique la forme des requĂȘtes de chaque type


Prompt Claude pour auditer tes requĂȘtes

Tu es un data engineer senior qui connaĂźt les bases relationnelles, document,
clé-valeur, graphe et les entrepÎts colonnaires (BigQuery, Snowflake).
 
Je vais te donner une ou plusieurs requĂȘtes SQL ainsi que le contexte
(moteur utilisé, origine des données, volumétrie approximative).
 
Pour chaque requĂȘte, vĂ©rifie :
 
1. Type de source : la donnée provient-elle d'une base relationnelle, d'une
base document (colonnes JSON), d'un export clé-valeur, d'une structure
hiĂ©rarchique/graphe ? Le type de requĂȘte est-il adaptĂ© Ă  cette source ?
2. Grain : aprĂšs chaque JOIN, UNNEST, jsonb_array_elements ou LATERAL FLATTEN,
le grain change-t-il ? Y a-t-il un risque de double comptage d'une valeur
de niveau parent (montant de commande, nombre d'utilisateurs) ?
3. JSON : les extractions de champs sont-elles typées correctement (cast) ?
Les clés optionnelles sont-elles gérées (existence, NULL) ?
4. HiĂ©rarchies : y a-t-il des self-joins rĂ©pĂ©tĂ©s qui devraient ĂȘtre un
CTE récursif ? Le CTE récursif a-t-il un garde-fou contre les cycles
et une profondeur maximale ?
5. Colonnaire : y a-t-il des SELECT *, un LIMIT censé réduire le coût,
l'absence de filtre sur la colonne de partition ou de clustering ?
Estime l'ordre de grandeur des octets scannés.
6. Usage opĂ©rationnel : la requĂȘte tape-t-elle une base de production
(transactionnelle ou cache) pour un besoin analytique qui devrait
passer par le warehouse ?
 
Pour chaque problÚme trouvé :
- cite la ligne concernée
- explique le risque concret (résultat faux, coût, impact prod)
- donne un exemple chiffré si possible
 
Termine par :
- une version corrigĂ©e complĂšte de chaque requĂȘte, commentĂ©e
- un tableau récapitulatif : problÚme / gravité (haute, moyenne, basse) / correction
- une recommandation sur le type de base le plus adaptĂ© si la requĂȘte
révÚle un mauvais choix de stockage
 
Voici mes requĂȘtes et leur contexte :
[COLLE TES REQUÊTES ICI]
4-types-bases-de-donnees · 23

Récapitulatif

Type

Stocke

Interroge avec

Idéal pour

À Ă©viter pour

Réflexe SQL associé

Relationnelle

Tables, lignes

SQL

Transactions, données reliées

Schéma trÚs mouvant

Normalisation, JOIN, contraintes

Document

JSON / BSON

MQL, API

Objets complets, attributs variables

Reporting transverse

->>, UNNEST, attention au grain

Clé-valeur

clĂ© → valeur

GET / SET

Cache, sessions, compteurs

Toute agrégation

Exporter vers le warehouse

Graphe

NƓuds + relations

Cypher, Gremlin

Fraude, réseaux, recommandations

Agrégats massifs

WITH RECURSIVE

Bonus : colonnaire

Colonnes

SQL

Analytique sur gros volumes

Écritures unitaires frĂ©quentes

Pas de SELECT *, filtre de partition


✅ Checklist types de bases de donnĂ©es

  • ☐ Je sais citer les 4 familles et donner un exemple de moteur pour chacune

  • ☐ Je sais expliquer la diffĂ©rence entre stockage en ligne et en colonne (OLTP vs OLAP)

  • ☐ Je sais ce que garantit ACID et pourquoi la finance tourne sur du relationnel

  • ☐ Je sais extraire un champ et un sous-champ d'une colonne JSON

  • ☐ Je vĂ©rifie le grain de ma requĂȘte aprĂšs chaque UNNEST / jsonb_array_elements

  • ☐ Je ne fais jamais d'analyse directement sur un cache clĂ©-valeur de production

  • ☐ Je sais Ă©crire un CTE rĂ©cursif avec une condition d'arrĂȘt

  • ☐ Je n'utilise pas SELECT * sur un entrepĂŽt colonnaire

  • ☐ Je filtre sur la colonne de partition avant de lancer une requĂȘte coĂ»teuse

  • ☐ Face Ă  un besoin, je pars de la forme des requĂȘtes pour choisir le type de base


🚀 Prouve que tu sais interroger n'importe quelle donnĂ©e

ConnaĂźtre les 4 types de bases, c'est bien. Savoir Ă©crire la bonne requĂȘte quand la donnĂ©e arrive en JSON, en arbre ou en milliards de lignes, c'est ce qui fait la diffĂ©rence en entretien et en poste. Mesure-toi sur des cas rĂ©els.

👉 modai-lab.com/test-sql/ — Exercices calibrĂ©s · Cas business rĂ©els · Feedback senior


_Guide offert suite au post LinkedIn · EntraĂźnez-vous sur modai-lab.com/test-sql/ · Partagez librement ♻_