SQL Academy · Leçon

Repérer et corriger les requêtes lentes

Utilisez pg_stat_statements, log_min_duration_statement et EXPLAIN pour trouver les requêtes lentes et appliquer des corrections ciblées.

Leçon 4 sur 414 étapes

Repérer et corriger les requêtes lentes est une leçon SQL Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage SQL Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours SQL Academy comprend 4 leçons au total.

Étape 1 : trouver les requêtes lentes

N’optimisez pas à l’aveugle. Utilisez :

pg_stat_statements — les requêtes les plus fréquentes selon leur durée totale
log_min_duration_statement — consigne les requêtes dépassant un seuil
pgBadger — des rapports lisibles à partir des journaux

Configuration de pg_stat_statements

Activez l’extension et configurez shared_preload_libraries :

-- postgresql.conf
shared_preload_libraries = 'pg_stat_statements'

-- After restart:
CREATE EXTENSION pg_stat_statements;

Les 10 requêtes les plus lourdes

La requête la plus utile pour tout DBA :

SELECT query,
       calls,
       total_exec_time,
       mean_exec_time,
       rows
FROM pg_stat_statements
ORDER BY total_exec_time DESC
LIMIT 10;

Journaliser les requêtes lentes

Définissez un seuil et consultez le journal :

-- postgresql.conf
log_min_duration_statement = '500ms'
-- All queries running > 500ms are logged.

Étape 2 : reproduire avec EXPLAIN ANALYZE

Pour chaque requête lente, exécutez EXPLAIN ANALYZE dans un environnement représentatif (avec des données proches de la production). Examinez :

Le nœud dont la durée réelle est la plus élevée
L’écart le plus important entre les lignes estimées et réelles
La bonne utilisation des index appropriés

Correctifs courants

Index manquant sur une colonne de WHERE / JOIN
Prédicat non optimisable par index (fonction appliquée à la colonne) — ajoutez un index d’expression ou réécrivez la requête
Statistiques obsolètes — exécutez ANALYZE
Type de données incorrect (qui provoque une conversion implicite) — corrigez le type de la colonne
Conditions OR — réécrivez-les comme une UNION de requêtes à condition unique
SELECT * récupère trop de données — réduisez la projection

Statistiques obsolètes

Si le nombre de lignes estimé diffère fortement du nombre réel, commencez par exécuter ANALYZE :

ANALYZE orders;
-- Or rely on autovacuum to do it periodically.

Vérification de cohérence des index

Répertoriez les index d’une table ainsi que leur taille :

SELECT indexrelname, pg_size_pretty(pg_relation_size(indexrelid))
FROM pg_stat_user_indexes
WHERE relname = 'orders'
ORDER BY pg_relation_size(indexrelid) DESC;

Index inutilisés

Trouvez les index qui ne sont jamais utilisés :

SELECT schemaname, relname, indexrelname, idx_scan
FROM pg_stat_user_indexes
WHERE idx_scan = 0
ORDER BY pg_relation_size(indexrelid) DESC;
-- Consider dropping them — they slow writes for no read benefit.

Contention sur les verrous

Parfois, une requête est "lente" parce qu’elle attend un verrou. Consultez pg_stat_activity pour wait_event :

SELECT pid, state, wait_event_type, wait_event, query
FROM pg_stat_activity
WHERE state <> 'idle';

Schémas de réécriture de requêtes

Déplacez les filtres dans WHERE
Remplacez la sous-requête corrélée de SELECT par une jointure avec GROUP BY
Remplacez OR par une UNION ALL de requêtes indexées
Utilisez des fonctions de fenêtrage plutôt que des auto-jointures
Matérialisez les sous-requêtes répétées avec des expressions de table communes (lorsque le planificateur est désorienté)

Itérer

Le réglage des performances est une boucle : mesurer → émettre une hypothèse → modifier → mesurer. Ne devinez pas.

Récapitulatif

Trouvez les requêtes lentes avec pg_stat_statements, diagnostiquez-les avec EXPLAIN ANALYZE, corrigez-les avec des index / ANALYZE / des réécritures, puis itérez.

Vérification rapide

Quelle extension PostgreSQL fait apparaître les requêtes les plus coûteuses en temps total d’exécution ?

Réponds-y dans la leçon interactive

Gratuit pour commencer

Apprends SQL avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 46
Leçons: 183

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Repérer et corriger les requêtes lentes » est-elle gratuite ?

Oui — le texte complet de « Repérer et corriger les requêtes lentes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours SQL Academy, passe à CoddyKit PRO. Le cours SQL Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Repérer et corriger les requêtes lentes » ?

Utilisez pg_stat_statements, log_min_duration_statement et EXPLAIN pour trouver les requêtes lentes et appliquer des corrections ciblées. Tu pratiques SQL Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer SQL Academy ?

Aucune expérience préalable n'est requise. SQL Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Repérer et corriger les requêtes lentes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon SQL Academy ?

Oui. Chaque leçon SQL Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Lire EXPLAIN et EXPLAIN ANALYZE
Parcours séquentiels ou parcours d’index
Jointure par hachage, jointure par fusion ou boucle imbriquée
Repérer et corriger les requêtes lentes

← Retour à SQL Academy