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


Pourquoi ce guide existe

« Tu connais SQL ou MySQL ? » C'est probablement la question la plus posée par les recruteurs non techniques… et la confusion la plus répandue chez les débutants.

Le problème concret :

  • Tu apprends « le SQL » sur un tuto MySQL, puis tu arrives dans une boîte qui tourne sur PostgreSQL ou BigQuery, et la moitié de tes requêtes plantent.

  • Tu vois LIMIT, TOP, FETCH FIRST et tu ne sais pas lequel est « le bon ».

  • En entretien, on te demande la différence entre SQL et MySQL et tu réponds « MySQL c'est une version de SQL » (presque, mais pas tout à fait).

Ce que ce guide couvre :

  • La différence fondamentale : un langage vs un logiciel

  • Ce qui est portable d'un moteur à l'autre (la bonne nouvelle : la majorité)

  • Les dialectes : ce qui change vraiment entre MySQL, PostgreSQL, SQL Server, BigQuery

  • Les pièges silencieux quand tu changes de moteur (résultats faux sans aucune erreur)

  • Comment répondre proprement en entretien

  • Un prompt Claude pour auditer la portabilité de tes requêtes


🧪 Calibre ton niveau avant de commencer

Sais-tu écrire une requête qui tourne à l'identique sur MySQL, PostgreSQL et BigQuery ? Si tu hésites, c'est le bon moment pour mesurer où tu en es. Fais le test en 5 minutes.

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

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


PARTIE 1 — SQL est un langage, MySQL est un logiciel

La réponse en une phrase

SQL (Structured Query Language) est un langage standardisé pour interroger et manipuler des bases de données relationnelles. MySQL est un SGBDR (Système de Gestion de Base de Données Relationnelle) : un logiciel qui stocke les données et exécute les requêtes écrites en SQL.

L'analogie la plus parlante :

Analogie

SQL

Le code de la route : les règles communes

MySQL

Une voiture précise : elle respecte le code, mais a ses propres boutons

PostgreSQL, SQL Server, BigQuery…

D'autres voitures, mêmes règles, tableaux de bord différents

Savoir conduire (SQL), c'est pouvoir conduire n'importe quelle voiture après 10 minutes d'adaptation. Connaître uniquement les boutons d'un modèle (MySQL), c'est fragile.

Ce qui se passe sous le capot

Quand tu écris une requête, voici ce qui se passe :

Toi ──► requête SQL (texte) ──► MySQL (le moteur)
│
├─ 1. Parse : vérifie la syntaxe
├─ 2. Optimise : choisit un plan (index, ordre des jointures)
├─ 3. Exécute : lit les fichiers sur disque (InnoDB)
└─ 4. Renvoie un résultat tabulaire
sql-vs-mysql · 01

SQL décrit quoi tu veux. Le moteur décide comment l'obtenir. C'est pour ça que la même requête peut être rapide sur un moteur et lente sur un autre : le texte est identique, le plan d'exécution ne l'est pas.

Un peu d'histoire (utile en entretien)

  • SQL est né chez IBM dans les années 1970 (initialement « SEQUEL »), puis normalisé par l'ANSI et l'ISO (norme ISO/IEC 9075). Le standard évolue régulièrement : SQL-92, SQL:1999 (CTE récursives), SQL:2003 (fonctions de fenêtre), etc.

  • MySQL est apparu au milieu des années 1990, est devenu la base du web (stack LAMP : Linux, Apache, MySQL, PHP), a été racheté par Sun puis est passé sous Oracle. Il est open source (licence GPL) avec une édition commerciale.

  • MariaDB est un fork de MySQL créé par son fondateur original. Très compatible, mais pas identique.

La carte des moteurs que tu vas croiser

Moteur

Éditeur / type

Dialecte

Où tu le croises

MySQL

Oracle, open source

SQL MySQL

Sites web, e-commerce, back-ends applicatifs

MariaDB

Communauté, open source

Proche MySQL

Hébergeurs, distributions Linux

PostgreSQL

Communauté, open source

Très proche du standard

SaaS, startups, data apps

SQL Server

Microsoft

T-SQL

Grands comptes, banque, assurance, industrie

Oracle Database

Oracle

PL/SQL

Banque, télécom, ERP historiques

SQLite

Embarqué

SQL léger

Mobile, prototypes, fichiers locaux

BigQuery

Google Cloud

GoogleSQL

Data warehouse, analytics

Snowflake

Cloud

SQL Snowflake

Data warehouse, analytics

❌ La confusion classique du débutant

-- ❌ Le débutant pense que ceci est "du SQL"
SELECT TOP nom, montant
FROM orders
ORDER BY montant DESC;
 
-- Sur MySQL : erreur de syntaxe.
-- TOP n'est pas du SQL standard : c'est du T-SQL (SQL Server).
-- Le débutant conclut "MySQL est buggé" alors qu'il a juste écrit dans le mauvais dialecte.
sql-vs-mysql · 02

✅ Ce que fait le senior

-- ✅ Le senior sait que la limitation de lignes varie selon le moteur
-- et choisit la syntaxe adaptée (ou la syntaxe standard quand elle est supportée)
 
-- MySQL / PostgreSQL / SQLite / BigQuery / Snowflake
SELECT nom, montant
FROM orders
ORDER BY montant DESC
LIMIT ;
 
-- Standard SQL:2008 (PostgreSQL, Oracle 12c+, SQL Server 2012+ avec OFFSET)
SELECT nom, montant
FROM orders
ORDER BY montant DESC
FETCH FIRST ROWS ONLY;
 
-- Gain : tu sais pourquoi ça plante, et tu corriges en 10 secondes au lieu de 30 minutes.
sql-vs-mysql · 03

Cas business : le stagiaire e-commerce

Contexte : une boutique en ligne de 18 000 commandes par mois tourne sur MySQL. Le stagiaire a appris sur SQL Server à l'école et copie une requête d'un ancien TP pour sortir les 5 plus gros paniers de la semaine.

-- Données d'exemple (orders)
-- order_id | user_id | montant | created_at
-- 10421 | 88 | 1 249.00 | 2026-11-02
-- 10433 | 12 | 980.50 | 2026-11-03
-- 10450 | 301 | 742.00 | 2026-11-04
-- 10458 | 88 | 615.90 | 2026-11-04
-- 10471 | 57 | 590.00 | 2026-11-05
-- ...
 
-- Version qui tourne sur MySQL
SELECT order_id, user_id, montant, created_at
FROM orders
WHERE created_at >= CURRENT_DATE - INTERVAL DAY
ORDER BY montant DESC
LIMIT ;
 
-- Résultat attendu : les 5 lignes ci-dessus, triées par montant décroissant.
-- Note : "CURRENT_DATE - INTERVAL 7 DAY" est une écriture MySQL.
-- En PostgreSQL : CURRENT_DATE - INTERVAL '7 days'
-- En BigQuery : DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY)
sql-vs-mysql · 04

🧪 Entraîne-toi sur de vraies bases, pas sur des TP scolaires

Sur Modai Lab, tu travailles sur des datasets e-commerce, SaaS et finance réalistes, avec des requêtes qui ressemblent à ce qu'on te demandera vraiment en poste.

👉 Pratiquer sur modai-lab.com

_Cas business réels · Feedback IA immédiat · Progression mesurée_


PARTIE 2 — Ce qui est portable : le socle commun (≈ 80 % de ton quotidien)

La bonne nouvelle

Si tu maîtrises le SQL standard, tu maîtrises l'essentiel de tous les moteurs. Ces briques fonctionnent partout (MySQL 8.0+, PostgreSQL, SQL Server, BigQuery, Snowflake…) :

  • SELECT, FROM, WHERE, ORDER BY

  • INNER JOIN, LEFT JOIN

  • GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX

  • CASE WHEN ... THEN ... ELSE ... END

  • COALESCE, NULLIF

  • IN, BETWEEN, LIKE, IS NULL

  • UNION ALL

  • Sous-requêtes et CTE (WITH ... AS)

  • Fonctions de fenêtre : ROW_NUMBER(), RANK(), SUM() OVER (...), LAG()

⚠️ Point d'attention MySQL : les CTE et les fonctions de fenêtre ne sont arrivées qu'avec MySQL 8.0. Si ton entreprise tourne encore sur MySQL 5.7, elles n'existent pas. C'est un vrai sujet sur des stacks legacy.

❌ Le réflexe du débutant : utiliser les fonctions propres au moteur partout

-- ❌ Requête qui ne tourne QUE sur MySQL
SELECT
user_id,
IFNULL(region, 'Inconnue') AS region, -- IFNULL : MySQL / BigQuery, pas PostgreSQL
IF(montant > , 'gros', 'petit') AS segment, -- IF() : MySQL uniquement (et BigQuery)
DATE_FORMAT(created_at, '%Y-%m') AS mois -- DATE_FORMAT : MySQL uniquement
FROM orders;
 
-- Le jour où l'équipe migre vers PostgreSQL ou un warehouse,
-- chaque ligne de cette requête est à réécrire.
sql-vs-mysql · 05

✅ Le réflexe senior : privilégier le standard quand il existe

-- ✅ Version portable (à part le formatage de date, voir Partie 3)
SELECT
user_id,
COALESCE(region, 'Inconnue') AS region, -- standard, partout
CASE WHEN montant > THEN 'gros' ELSE 'petit' END AS segment, -- standard, partout
EXTRACT(YEAR FROM created_at) AS annee, -- standard
EXTRACT(MONTH FROM created_at) AS mois -- standard
FROM orders;
 
-- Gain : la requête survit à une migration, et n'importe quel analyste la comprend.
sql-vs-mysql · 06

Cas business : cohortes SaaS en SQL 100 % portable

Contexte : un SaaS B2B (abonnements mensuels à 49 €, 99 € et 249 €) veut le chiffre d'affaires par mois de souscription et le rang de chaque client dans son plan. La requête doit tourner sur la base de prod MySQL et sur le warehouse.

-- Données d'exemple (subscriptions)
-- user_id | plan | prix_mensuel | started_at | statut
-- 1 | starter | 49 | 2026-08-14 | actif
-- 2 | pro | 99 | 2026-08-20 | actif
-- 3 | business | 249 | 2026-09-02 | resilie
-- 4 | pro | 99 | 2026-09-11 | actif
-- 5 | pro | 99 | 2026-09-28 | actif
 
WITH abonnements AS (
SELECT
user_id,
plan,
prix_mensuel,
EXTRACT(YEAR FROM started_at) AS annee,
EXTRACT(MONTH FROM started_at) AS mois,
started_at
FROM subscriptions
WHERE statut = 'actif'
),
classement AS (
SELECT
user_id,
plan,
annee,
mois,
prix_mensuel,
ROW_NUMBER() OVER (PARTITION BY plan ORDER BY started_at) AS rang_dans_plan
FROM abonnements
)
SELECT
annee,
mois,
COUNT(*) AS nb_nouveaux_actifs,
SUM(prix_mensuel) AS mrr_ajoute
FROM classement
GROUP BY annee, mois
ORDER BY annee, mois;
 
-- Résultat :
-- annee | mois | nb_nouveaux_actifs | mrr_ajoute
-- 2026 | 8 | 2 | 148
-- 2026 | 9 | 2 | 198
--
-- Tourne à l'identique sur MySQL 8.0+, PostgreSQL, SQL Server, BigQuery, Snowflake.
sql-vs-mysql · 07

🧪 Vérifie que ton SQL est vraiment « standard »

Le test Modai Lab évalue ta maîtrise du socle commun (jointures, agrégations, CTE, fenêtres) : exactement ce qui te suit d'un moteur à l'autre.

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

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


PARTIE 3 — Les dialectes : ce qui change vraiment entre MySQL et les autres

Le mécanisme

Chaque éditeur implémente le standard plus ses propres extensions (pour la performance, la rétrocompatibilité ou le confort). Résultat : un dialecte. Les différences se concentrent toujours sur les mêmes zones : limitation de lignes, dates, chaînes de caractères, gestion des NULL, identifiants, insertion/mise à jour.

La table de traduction à garder sous la main

Besoin

MySQL

PostgreSQL

SQL Server (T-SQL)

BigQuery

Limiter les lignes

LIMIT 10

LIMIT 10

TOP 10 / OFFSET ... FETCH

LIMIT 10

Concaténer

CONCAT(a, b)

`a \

\

b ou CONCAT`

a + b ou CONCAT

CONCAT ou `a \

\

b`

Valeur par défaut si NULL

IFNULL / COALESCE

COALESCE

ISNULL / COALESCE

IFNULL / COALESCE

Date du jour

CURDATE()

CURRENT_DATE

CAST(GETDATE() AS DATE)

CURRENT_DATE()

Formater une date

DATE_FORMAT(d, '%Y-%m')

TO_CHAR(d, 'YYYY-MM')

FORMAT(d, 'yyyy-MM')

FORMAT_DATE('%Y-%m', d)

Tronquer au mois

DATE_FORMAT(d, '%Y-%m-01')

DATE_TRUNC('month', d)

DATETRUNC(month, d) (2022+)

DATE_TRUNC(d, MONTH)

Écart en jours

DATEDIFF(fin, debut)

fin - debut

DATEDIFF(day, debut, fin)

DATE_DIFF(fin, debut, DAY)

Protéger un nom de colonne

order

"order"

[order]

order

Upsert

ON DUPLICATE KEY UPDATE

ON CONFLICT ... DO UPDATE

MERGE

MERGE

Booléen

TINYINT(1) (alias BOOLEAN)

BOOLEAN natif

BIT

BOOL natif

Auto-incrément

AUTO_INCREMENT

GENERATED AS IDENTITY / SERIAL

IDENTITY(1,1)

pas d'auto-incrément

Note bien l'ordre des arguments de DATEDIFF : il est inversé entre MySQL et SQL Server. Source de bugs garantie.

❌ Requête MySQL copiée-collée dans PostgreSQL

-- ❌ Écrite pour MySQL, exécutée sur PostgreSQL
SELECT
`user_id`, -- backticks : erreur de syntaxe en PostgreSQL
CONCAT(prenom, ' ', nom) AS client, -- OK (CONCAT existe aussi en PG)
DATE_FORMAT(created_at, '%Y-%m') AS mois, -- fonction inexistante en PG
DATEDIFF(NOW(), created_at) AS anciennete -- DATEDIFF n'existe pas en PG
FROM users
LIMIT ;
sql-vs-mysql · 08

✅ La même requête traduite proprement

-- ✅ Version PostgreSQL
SELECT
user_id, -- pas besoin de guillemets si le nom est simple
prenom || ' ' || nom AS client,
TO_CHAR(created_at, 'YYYY-MM') AS mois,
CURRENT_DATE - created_at::date AS anciennete -- soustraction de dates = nombre de jours
FROM users
LIMIT ;
 
-- ✅ Version BigQuery
SELECT
user_id,
CONCAT(prenom, ' ', nom) AS client,
FORMAT_DATE('%Y-%m', DATE(created_at)) AS mois,
DATE_DIFF(CURRENT_DATE(), DATE(created_at), DAY) AS anciennete
FROM users
LIMIT ;
 
-- Gain : tu identifies les 4 zones à risque (identifiants, chaînes, dates, écarts)
-- et tu traduis méthodiquement au lieu de corriger erreur par erreur.
sql-vs-mysql · 09

Cas business : l'upsert de stock e-commerce

Contexte : chaque nuit, un fichier fournisseur met à jour les stocks de 4 200 références. Si le produit existe, on met à jour la quantité ; sinon, on l'insère. Chaque moteur a sa syntaxe.

-- Table products : product_id (clé primaire) | nom | stock | updated_at
-- Ligne entrante : product_id = 'SKU-1042', nom = 'Sac cuir camel', stock = 37
 
-- MySQL
INSERT INTO products (product_id, nom, stock, updated_at)
VALUES ('SKU-1042', 'Sac cuir camel', , NOW())
ON DUPLICATE KEY UPDATE
stock = VALUES(stock), -- en MySQL 8.0.20+, préférer un alias : AS new ... stock = new.stock
updated_at = NOW();
 
-- PostgreSQL
INSERT INTO products (product_id, nom, stock, updated_at)
VALUES ('SKU-1042', 'Sac cuir camel', , NOW())
ON CONFLICT (product_id) DO UPDATE
SET stock = EXCLUDED.stock,
updated_at = NOW();
 
-- SQL Server / BigQuery / Snowflake (standard MERGE)
MERGE INTO products AS cible
USING (SELECT 'SKU-1042' AS product_id, 'Sac cuir camel' AS nom, AS stock) AS source
ON cible.product_id = source.product_id
WHEN MATCHED THEN
UPDATE SET stock = source.stock, updated_at = CURRENT_TIMESTAMP
WHEN NOT MATCHED THEN
INSERT (product_id, nom, stock, updated_at)
VALUES (source.product_id, source.nom, source.stock, CURRENT_TIMESTAMP);
 
-- Même intention métier, trois syntaxes. Le concept (upsert) est ce qui compte en entretien.
sql-vs-mysql · 10

🧪 Passe d'un dialecte à l'autre sans stress

Sur Modai Lab, les exercices te confrontent à des situations réelles où la syntaxe change mais la logique reste. L'IA t'explique pourquoi ta requête plante et comment la corriger.

👉 Pratiquer sur modai-lab.com

_Exercices guidés · Explications pas à pas · Cas e-commerce, SaaS, finance_


PARTIE 4 — Les pièges silencieux : même requête, résultat différent

Pourquoi c'est la partie la plus importante

Une erreur de syntaxe, tu la vois tout de suite. Le vrai danger, c'est la requête qui s'exécute sans erreur sur les deux moteurs mais renvoie un résultat différent. C'est comme ça qu'un KPI dérive après une migration sans que personne ne s'en rende compte.

Piège 1 — La division entière

-- Données : 7 commandes livrées sur 9 commandes passées
 
SELECT / AS taux;
 
-- MySQL → 0.7778 (division décimale)
-- BigQuery → 0.777… (FLOAT64)
-- PostgreSQL → 0 (entier / entier = division entière !)
-- SQL Server → 0 (idem)
sql-vs-mysql · 11
-- ❌ Taux de livraison qui tombe à 0 % après migration vers PostgreSQL
SELECT
COUNT(CASE WHEN statut = 'livree' THEN END) / COUNT(*) AS taux_livraison
FROM orders;
 
-- ✅ Version robuste partout : forcer une division décimale
SELECT
COUNT(CASE WHEN statut = 'livree' THEN END) * . / NULLIF(COUNT(*), ) AS taux_livraison
FROM orders;
-- NULLIF évite au passage la division par zéro.
sql-vs-mysql · 12

Piège 2 — La casse dans les comparaisons de texte

-- Données (users) : email = 'Paul.Martin@Gmail.com'
 
SELECT * FROM users WHERE email = 'paul.martin@gmail.com';
 
-- MySQL (collation par défaut *_ci = case insensitive) → 1 ligne trouvée
-- PostgreSQL / BigQuery (comparaison sensible à la casse) → 0 ligne
sql-vs-mysql · 13
-- ✅ Version explicite et portable
SELECT * FROM users WHERE LOWER(email) = LOWER('paul.martin@gmail.com');
sql-vs-mysql · 14

Conséquence métier : une déduplication de clients faite sur MySQL peut donner plus de clients uniques une fois portée sur PostgreSQL. Ton CAC et ton panier moyen par client bougent.

Piège 3 — Le GROUP BY permissif

-- ❌ Colonne non agrégée et absente du GROUP BY
SELECT user_id, region, SUM(montant) AS ca
FROM orders
GROUP BY user_id;
 
-- MySQL avec ONLY_FULL_GROUP_BY désactivé (vieilles configs, 5.6 et avant par défaut) :
-- la requête passe et renvoie une "region" arbitraire parmi celles de l'utilisateur.
-- MySQL 5.7.5+ (mode par défaut), PostgreSQL, SQL Server, BigQuery : erreur.
 
-- ✅ Toujours grouper (ou agréger) toutes les colonnes non agrégées
SELECT user_id, region, SUM(montant) AS ca
FROM orders
GROUP BY user_id, region;
sql-vs-mysql · 15

Piège 4 — `||` qui ne concatène pas

SELECT 'Mo' || 'dai' AS nom;
 
-- PostgreSQL, Oracle, SQLite, BigQuery → 'Modai'
-- MySQL (mode par défaut) → 0 (|| est un OU logique, sauf si PIPES_AS_CONCAT est activé)
-- ✅ Utilise CONCAT('Mo', 'dai') si ta requête doit tourner sur MySQL.
sql-vs-mysql · 16

Piège 5 — Ce que MySQL ne sait pas faire

-- ❌ FULL OUTER JOIN : n'existe pas en MySQL
SELECT c.client_id, c.solde_crm, f.solde_compta
FROM crm_soldes c
FULL OUTER JOIN compta_soldes f ON f.client_id = c.client_id;
 
-- ✅ Contournement MySQL : LEFT JOIN + les lignes orphelines de droite
SELECT c.client_id, c.solde_crm, f.solde_compta
FROM crm_soldes c
LEFT JOIN compta_soldes f ON f.client_id = c.client_id
UNION ALL
SELECT f.client_id, NULL, f.solde_compta
FROM compta_soldes f
LEFT JOIN crm_soldes c ON c.client_id = f.client_id
WHERE c.client_id IS NULL;
sql-vs-mysql · 17

Cas business : la réconciliation finance qui ne tombait plus juste

Contexte : une fintech migre son reporting de MySQL vers BigQuery. Le rapport mensuel de rapprochement compare 12 480 transactions entre le CRM et la comptabilité. Après migration, l'écart passe de 3 transactions à 41.

-- Données d'exemple
-- crm_transactions compta_transactions
-- ref | montant ref | montant
-- 'TX-0091' | 120.00 'tx-0091' | 120.00 ← casse différente
-- 'TX-0092' | 89.90 'TX-0092' | 89.90
-- 'TX-0093' | 450.00 (absente)
 
-- ❌ Requête d'origine (MySQL) : la jointure ignore la casse grâce à la collation
SELECT COUNT(*) AS nb_ecarts
FROM crm_transactions c
LEFT JOIN compta_transactions f ON f.ref = c.ref
WHERE f.ref IS NULL;
-- MySQL → 1 écart (TX-0093)
-- BigQuery → 2 écarts (TX-0091 n'est plus rapprochée)
 
-- ✅ Version explicite, identique sur les deux moteurs
SELECT COUNT(*) AS nb_ecarts
FROM crm_transactions c
LEFT JOIN compta_transactions f
ON UPPER(TRIM(f.ref)) = UPPER(TRIM(c.ref))
WHERE f.ref IS NULL;
-- → 1 écart sur les deux moteurs.
 
-- Leçon : la "vraie" règle métier (les références sont insensibles à la casse)
-- était cachée dans la configuration du moteur. Rends-la explicite dans le SQL.
sql-vs-mysql · 18

🧪 Les pièges silencieux, ça se repère à l'entraînement

Ce sont exactement ces cas (division entière, casse, NULL, GROUP BY) que le test Modai Lab utilise pour distinguer un niveau junior d'un niveau confirmé.

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

_Pièges réels · Correction détaillée · Niveau junior → senior_


PARTIE 5 — Lequel apprendre, et comment répondre en entretien

Faut-il apprendre MySQL, PostgreSQL ou BigQuery ?

La bonne question n'est pas « quel moteur » mais « quel SQL ». Ordre recommandé :

  1. Le SQL standard d'abord : jointures, agrégations, CTE, fonctions de fenêtre, gestion des NULL. C'est 80 % du job, partout.

  2. Le moteur de ta cible ensuite :

- Développement web / back-end → MySQL ou PostgreSQL - Data analyst / analytics engineer → BigQuery, Snowflake ou PostgreSQL - Grands comptes, banque, assurance → SQL Server ou Oracle

  1. Les spécificités en dernier : fonctions de dates, upsert, types, optimisation (index, partitions, coûts).

Un analyste solide sur le standard s'adapte à un nouveau moteur en quelques jours, avec la doc et une table de traduction comme celle de la Partie 3.

❌ La réponse junior en entretien

« MySQL c'est un type de SQL, c'est la même chose mais en plus récent. »

Problèmes : confusion langage / logiciel, et « plus récent » est faux (SQL est antérieur à MySQL d'environ 20 ans).

✅ La réponse senior en entretien (30 secondes)

« SQL est un langage standardisé (ISO) pour interroger des bases relationnelles. MySQL est un SGBD relationnel open source, édité par Oracle, qui exécute du SQL avec son propre dialecte. Le socle (SELECT, JOIN, GROUP BY, CTE, fenêtres depuis la 8.0) est commun avec PostgreSQL, SQL Server ou BigQuery ; les différences portent surtout sur les dates, les chaînes, la limitation de lignes et l'upsert. Il y a aussi des pièges silencieux, comme la division entière ou la sensibilité à la casse, que je vérifie systématiquement quand je change de moteur. »

Pourquoi ça marche : tu montres que tu distingues les concepts, que tu connais l'écosystème, et que tu as déjà été confronté aux vrais problèmes.

Cas business : la question piège en entretien SaaS

Le recruteur : « Notre prod est sur MySQL, notre warehouse sur BigQuery. Calcule le taux de churn mensuel, et la requête doit tourner sur les deux. »

-- Données d'exemple (subscriptions)
-- user_id | started_at | ended_at
-- 1 | 2026-06-03 | NULL
-- 2 | 2026-06-15 | 2026-09-10
-- 3 | 2026-07-01 | NULL
-- 4 | 2026-07-22 | 2026-09-28
-- 5 | 2026-08-05 | NULL
 
-- Churn de septembre 2026 = clients partis en septembre / clients actifs au 1er septembre
 
WITH actifs_debut AS (
SELECT COUNT(*) AS nb
FROM subscriptions
WHERE started_at < DATE '2026-09-01'
AND (ended_at IS NULL OR ended_at >= DATE '2026-09-01')
),
partis AS (
SELECT COUNT(*) AS nb
FROM subscriptions
WHERE ended_at >= DATE '2026-09-01'
AND ended_at < DATE '2026-10-01'
)
SELECT
a.nb AS actifs_au_1er,
p.nb AS partis_dans_le_mois,
ROUND(p.nb * . / NULLIF(a.nb, ), ) AS churn_pct
FROM actifs_debut a
CROSS JOIN partis p;
 
-- Résultat :
-- actifs_au_1er | partis_dans_le_mois | churn_pct
-- 5 | 2 | 40.0
--
-- Choix portables : littéraux DATE '...' (standard), bornes en >= / < (pas de BETWEEN sur des dates),
-- * 100.0 pour éviter la division entière, NULLIF contre la division par zéro, CROSS JOIN standard.
sql-vs-mysql · 19

🧪 Prépare tes entretiens sur des cas qui ressemblent aux vrais

Churn, cohortes, rapprochements, top N : Modai Lab propose des exercices calqués sur les questions posées en entretien data, avec un feedback précis sur ta requête.

👉 Pratiquer sur modai-lab.com

_Questions d'entretien réelles · Correction commentée · Progression suivie_


Prompt Claude pour auditer tes requêtes

Copie-colle ce prompt dans Claude, puis colle ta requête à la fin.

Tu es un expert SQL senior qui connaît parfaitement les dialectes MySQL, PostgreSQL,
SQL Server (T-SQL), BigQuery (GoogleSQL) et Snowflake.
 
Je vais te donner une requête SQL. Indique-moi d'abord sur quel moteur elle a été
écrite (déduis-le de la syntaxe si je ne le précise pas), puis audite sa portabilité.
 
Vérifie systématiquement :
1. Syntaxe propre à un moteur : LIMIT / TOP / FETCH FIRST, backticks / guillemets / crochets,
IFNULL / ISNULL / NVL, IF(), CONCAT vs || vs +.
2. Fonctions de dates : DATE_FORMAT, TO_CHAR, FORMAT_DATE, DATEDIFF (ordre des arguments !),
DATE_TRUNC, INTERVAL, CURDATE / CURRENT_DATE / GETDATE.
3. Pièges silencieux (même requête, résultat différent) :
- division entière (entier / entier)
- sensibilité à la casse des comparaisons et des jointures sur du texte
- GROUP BY avec des colonnes non agrégées
- || interprété comme OU logique en MySQL
- gestion des NULL dans les agrégats et les comparaisons
4. Fonctionnalités absentes de certains moteurs : FULL OUTER JOIN (MySQL),
CTE et fonctions de fenêtre (MySQL < 8.0), MERGE, ON CONFLICT, ON DUPLICATE KEY UPDATE.
5. Divisions par zéro non protégées.
 
Pour chaque problème trouvé, donne :
- la ligne concernée
- le moteur sur lequel ça casse ou change de résultat
- le niveau de risque (erreur visible / résultat silencieusement faux)
 
Ensuite, propose :
- une version la plus portable possible (SQL standard en priorité)
- si nécessaire, une version spécifique pour chaque moteur cible que je t'indique
- un commentaire SQL court au-dessus de chaque modification expliquant le pourquoi
 
Moteur cible : [MySQL / PostgreSQL / BigQuery / SQL Server / Snowflake / tous]
 
Ma requête :
[colle ta requête ici]
sql-vs-mysql · 20

📋 Récapitulatif

Sujet

À retenir

SQL

Un langage standardisé (ISO/IEC 9075), né chez IBM dans les années 1970

MySQL

Un logiciel (SGBDR) open source édité par Oracle, qui exécute du SQL

Dialecte

Chaque moteur = standard + extensions maison

Portable partout

SELECT, JOIN, GROUP BY, HAVING, CASE, COALESCE, CTE, fenêtres

MySQL < 8.0

Pas de CTE ni de fonctions de fenêtre

Limiter les lignes

LIMIT (MySQL, PG, BigQuery) · TOP (SQL Server) · FETCH FIRST (standard)

Dates

Zone de divergence n°1 : toujours vérifier la fonction et l'ordre des arguments

Upsert

ON DUPLICATE KEY UPDATE (MySQL) · ON CONFLICT (PG) · MERGE (standard)

Division

7 / 9 = 0.78 en MySQL, 0 en PostgreSQL et SQL Server → * 1.0

Casse

MySQL insensible par défaut, PostgreSQL/BigQuery sensibles → LOWER() explicite

`\

\

`

Concaténation partout… sauf MySQL où c'est un OU logique par défaut

FULL OUTER JOIN

Absent de MySQL → LEFT JOIN + UNION ALL

Apprendre

Standard d'abord, moteur de ta cible ensuite, spécificités en dernier


✅ Checklist SQL vs MySQL

  • ☐ Je sais expliquer en une phrase que SQL est un langage et MySQL un SGBDR

  • ☐ Je connais au moins 4 autres moteurs et leur usage typique

  • ☐ Je privilégie COALESCE et CASE WHEN plutôt que IFNULL et IF()

  • ☐ Je sais limiter les lignes sur MySQL, SQL Server et en SQL standard

  • ☐ Je vérifie la fonction de date et l'ordre des arguments quand je change de moteur

  • ☐ Je force la division décimale (* 1.0) et je protège les divisions par zéro (NULLIF)

  • ☐ Je rends la casse explicite (LOWER / UPPER) sur les jointures et filtres texte

  • ☐ Toutes mes colonnes non agrégées sont dans le GROUP BY

  • ☐ J'utilise CONCAT() si ma requête doit tourner sur MySQL

  • ☐ Je sais contourner l'absence de FULL OUTER JOIN en MySQL

  • ☐ Je vérifie la version de MySQL avant d'utiliser CTE ou fonctions de fenêtre

  • ☐ J'ai une réponse d'entretien de 30 secondes prête sur SQL vs MySQL


🚀 Maîtrise le SQL, pas juste un moteur

Les moteurs changent au fil de ta carrière, le SQL reste. Entraîne-toi sur le socle commun et sur les pièges qui font la différence entre un junior et un senior.

👉 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 ♻️_