// outil gratuit

Visualiseur de plan de requête

Collez un plan d'exécution provenant de SQL Server, PostgreSQL, MySQL, MariaDB, SQLite, DuckDB, ClickHouse ou Oracle et voyez ce qui est lent, pourquoi, et ce qu'il faut changer - des constats classés par priorité, un arbre d'opérateurs et un diagramme de plan. C'est le lecteur de plans de l'application de bureau SQLly compilé en WebAssembly, donc il fonctionne dans votre navigateur et votre plan ne quitte jamais votre appareil.

Loading the plan reader…

Astuce : appuyez sur Ctrl+Entrée (⌘+Entrée sur un Mac) dans le champ pour lancer l'analyse. Les fichiers sont lus sur cet appareil avec le lecteur de fichiers de votre navigateur ; rien n'est téléversé.

Ce que fait ce visualiseur de plan d'exécution

Un plan de requête est la réponse de la base de données à « comment allez-vous l’exécuter ? » - quels index elle lit, comment elle joint, combien de lignes elle attend à chaque étape et où passe le coût. Les plans sont denses, et chaque moteur les écrit différemment. Ce visualiseur les ramène tous à un modèle unique et commence par l’essentiel : une liste classée des problèmes en langage clair, chacun avec la raison de son impact et une prochaine étape concrète.

  • D'abord les constats. Analyses complètes, index manquants, conversions implicites, recherches de clés, débordements, statistiques manquantes, jointures croisées, objectifs de ligne et estimations de lignes erronées - du pire au meilleur, avec l'opérateur auquel ils appartiennent et, pour les suggestions d'index manquants de SQL Server, une instruction prête à être passée en revue CREATE INDEX instruction.
  • Huit moteurs, une vue. Les plans de SQL Server, PostgreSQL, MySQL, MariaDB, SQLite, DuckDB, ClickHouse et Oracle se lisent de la même manière, donc vous n'avez pas besoin d'un outil différent pour chaque base de données.
  • Arbre et diagramme. L'arbre des opérateurs montre côte à côte la part de coût, les lignes estimées et les lignes réelles de chaque étape, avec en surbrillance les écarts d'estimation de 10× ou plus. Le diagramme présente le plan de haut en bas avec des barres de coût que vous pouvez parcourir en un coup d'œil.
  • Lots et sortie collée. Les plans SQL Server multi-instructions obtiennent un commutateur d'instructions. La sortie copiée depuis psql, le client mysql ou sqlplus est débarrassée de sa mise en forme pour vous - inutile de retirer les bordures ou + les continuations d'abord.
  • Privé. L'analyse complète s'exécute dans votre onglet. Les plans contiennent votre SQL, les noms de tables et parfois les valeurs de paramètres ; rien de tout cela n’est envoyé.

Comment obtenir un plan d'exécution pour chaque base de données

Chaque moteur a deux types de plan. Un estimé plan est la prédiction de l'optimiseur et n'exécute jamais l'instruction. Un réel le plan exécute l'instruction et enregistre le nombre réel de lignes - la seule façon de voir où l'optimiseur s'est trompé. La capture réelle exécute également les insertions, mises à jour et suppressions, donc les données de test changent à l'intérieur d'une transaction que vous annulez.

SQL Server et Azure SQL : ShowPlan XML

Plan réel - exécute la requête et retourne un document de plan par instruction, après les résultats :

SET STATISTICS XML ON;
SELECT ... ;   -- your query
SET STATISTICS XML OFF;

Plan estimé - compile sans exécution. SET SHOWPLAN_XML doit être la seule instruction de son lot, d'où les GO séparateurs :

SET SHOWPLAN_XML ON;
GO
SELECT ... ;   -- your query
GO
SET SHOWPLAN_XML OFF;

Dans SSMS, activez Inclure le plan d'exécution réel (Ctrl+M) ou utilisez Afficher le plan d'exécution estimé (Ctrl+L), puis faites un clic droit sur le plan graphique et choisissez Enregistrer le plan d'exécution sous… pour obtenir un .sqlplan fichier que vous pouvez ouvrir ici, ou Afficher le plan d'exécution XML… pour copier le XML. Les plans déjà en cache ou dans le Query Store fonctionnent également : sys.dm_exec_query_plan(plan_handle) retourne le XML, et sys.query_store_plan.query_plan le garde sous forme de texte. Si vous copiez un grand plan depuis la grille de résultats SSMS et que le visualiseur signale un XML incomplet, c'est la grille qui l'a tronqué (sa limite XML se règle sous Outils > Options > Résultats de requête > SQL Server > Résultats vers la grille) ; enregistrez plutôt le plan dans un fichier.

PostgreSQL : EXPLAIN (FORMAT JSON)

-- Actual plan: runs the query
EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) SELECT ... ;

-- Estimated plan: does not run it
EXPLAIN (FORMAT JSON) SELECT ... ;

-- Measure a data change without keeping it
BEGIN;
EXPLAIN (ANALYZE, FORMAT JSON) UPDATE ... ;
ROLLBACK;

Le visualiseur lit le format JSON, pas la sortie texte par défaut de PostgreSQL. Coller directement depuis psql marche - l'en-tête QUERY PLAN et + à la fin de chaque ligne sont supprimés - ou exécutez psql -XqAt -c "EXPLAIN (ANALYZE, FORMAT JSON) ..." pour une sortie propre. Pour les plans des requêtes exécutées par votre application, le auto_explain module peut les enregistrer avec auto_explain.log_format = json.

MySQL : EXPLAIN FORMAT=JSON et EXPLAIN ANALYZE

-- Estimated plan as JSON: does not run the query
EXPLAIN FORMAT=JSON SELECT ... ;

-- Actual plan (MySQL 8.0.18 and later): runs the query
EXPLAIN ANALYZE SELECT ... ;

Les deux sont lus, et le visualiseur les distingue par la forme. Les bordures de table du client mysql, \G les bannières de ligne et les pieds de page « 1 row in set » sont supprimés lors du collage. Les versions plus récentes de MySQL peuvent également émettre une deuxième disposition JSON (explain_json_format_version = 2); la visionneuse lit l'original, donc exécutez SET explain_json_format_version = 1; d'abord si votre serveur est par défaut en version 2.

MariaDB : EXPLAIN et ANALYZE FORMAT=JSON

-- Estimated plan: does not run the query
EXPLAIN FORMAT=JSON SELECT ... ;

-- Actual plan with r_rows, r_loops and timings: runs the query
ANALYZE FORMAT=JSON SELECT ... ;

SQLite : EXPLAIN QUERY PLAN

EXPLAIN QUERY PLAN SELECT ... ;

SQLite n'exécute jamais l'instruction pour EXPLAIN QUERY PLAN, et ses plans n'entraînent aucun coût ni estimation de ligne - juste les étapes, ce qui suffit encore pour repérer un SCAN qui devrait être un SEARCH. Le sqlite3 arbre du shell (QUERY PLAN, |--, `--) est lu tel quel, et il en va de même pour les données brutes id | parent | notused | detail lignes que d'autres outils retournent. Dans le shell, .eqp on imprime le plan avant chaque instruction que vous exécutez.

DuckDB : EXPLAIN (FORMAT JSON)

-- Estimated plan
EXPLAIN (FORMAT JSON) SELECT ... ;

-- Actual plan with per-operator rows and timing: runs the query
EXPLAIN (ANALYZE, FORMAT JSON) SELECT ... ;

Collez le JSON de la explain_value colonne. DuckDB n'a pas d'unités de coût, donc un plan réel nuance les opérateurs selon le temps qu'ils ont pris.

ClickHouse : EXPLAIN json = 1

EXPLAIN json = 1, indexes = 1
SELECT ...
FORMAT TSVRaw;

indexes = 1 ajoute combien de parties et de granules chaque clé primaire, clé de partition et index de saut ont conservé ; c’est ainsi que le visualiseur repère une lecture qui n’a rien supprimé. FORMAT TSVRaw renvoie le JSON sans échappement. ClickHouse n'a pas de EXPLAIN ANALYZE, donc ses plans sont toujours estimés.

Oracle Database : DBMS_XPLAN

-- Estimated plan: does not run the query
EXPLAIN PLAN FOR SELECT ... ;
SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);

-- Actual plan: run the query with row-source statistics, then read its cursor
SET SERVEROUTPUT OFF
SET LINESIZE 300
SELECT /*+ GATHER_PLAN_STATISTICS */ ... ;
SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY_CURSOR(NULL, NULL, 'ALLSTATS LAST'));

Collez toute la sortie, y compris la section Predicate Information - le visualiseur rattache chaque access et filter prédicat à son opération. DISPLAY_CURSOR a besoin d'un accès SELECT à V$SESSION, V$SQL, V$SQL_PLAN et V$SQL_PLAN_STATISTICS_ALL, accordé directement à l'utilisateur. Gardez SERVEROUTPUT désactivé dans SQL*Plus ou SQLcl, sinon le « dernier curseur » affiché est l'appel de sortie plutôt que votre requête, et élargissez LINESIZE pour que la table de plan ne passe pas à la ligne.

Ce que chaque résultat signifie et comment le corriger

Les constats sont classés par gravité, puis par la part de l'opérateur dans le coût de l'instruction ; la première carte est donc généralement le problème le plus coûteux que vous puissiez corriger. Chaque constat nomme l'opérateur dont il provient - sélectionnez-le pour vous y rendre dans l'arbre.

Index manquant

Ce que cela signifie. Lors de la compilation de l'instruction, SQL Server a calculé un index qui aurait rendu l'opération moins coûteuse et l'a enregistré dans le plan avec une amélioration estimée. Le visualiseur le rapporte une fois, sur l'opérateur qui lit cette table, et le transforme en une CREATE NONCLUSTERED INDEX instruction. Les suggestions avec un impact estimé de 90 % ou plus sont marquées comme critiques.

Comment le corriger. Considérez cette instruction comme un brouillon. L’optimiseur liste d’abord les colonnes d’égalité, puis les colonnes d’inégalité, puis les colonnes incluses, sans vérifier les index que vous possédez déjà - un index existant peut souvent être élargi au lieu d’ajouter un quasi-doublon, et chaque index ralentit les écritures. Vérifiez que l’ordre des colonnes clés convient à vos autres requêtes, puis créez-le et capturez à nouveau le plan. Cette observation provient uniquement des plans SQL Server ; d’autres moteurs n’enregistrent pas les suggestions d’index.

Analyse complète de la table

Ce que cela signifie. L'opérateur lit chaque ligne d'une table (ou d'un index entier) pour trouver celles dont il a besoin. Le visualiseur signale les analyses complètes de tables et les analyses d'index avec un prédicat résiduel sur SQL Server, PostgreSQL Seq Scan, MySQL et MariaDB access_type: ALL et Table scan on, SQLite SCAN étapes sans index, DuckDB scanne sans filtre poussé, ClickHouse lit des données dont les index n'ont pas éliminé de granules, et Oracle TABLE ACCESS FULL.

Comment le corriger. Un scan est le bon choix pour les petites tables et pour les requêtes qui nécessitent la plupart des lignes. Lorsque le filtre est sélectif, ajoutez un index sur les colonnes filtrées ou jointes, et assurez-vous que le prédicat peut l'utiliser : pas de fonction appliquée à la colonne (WHERE lower(email) = ... nécessite un index d'expression dans PostgreSQL), pas de caractère générique en début de LIKE '%x', et des types de données correspondants. Dans ClickHouse, filtrez sur un préfixe de la clé ORDER BY la clé ou ajoutez un index de saut.

Écart d'estimation de lignes

Ce que cela signifie. Un plan réel a lu au moins 10× plus ou moins de lignes que ce que l'optimiseur avait estimé pour cet opérateur. Chaque choix ultérieur - type de jointure, ordre de jointure, allocation de mémoire - a été fait sur la base d'un volume de données erroné, donc un gros écart en bas du plan explique souvent la lenteur de ce qui est au-dessus. Le constat n'apparaît que si le plan contient des statistiques d'exécution. Dans les plans SQL Server, l'estimation est comparée sur l'ensemble des exécutions de l'opérateur ; PostgreSQL indique les deux nombres pour chaque boucle.

Comment le corriger. Commencez par les statistiques : UPDATE STATISTICS sur SQL Server, ANALYZE sur PostgreSQL, ANALYZE TABLE sur MySQL et MariaDB, DBMS_STATS.GATHER_TABLE_STATS sur Oracle. Si les chiffres sont encore très éloignés, le prédicat est difficile à estimer : colonnes corrélées (le PostgreSQL CREATE STATISTICS aide), une fonction sur une colonne, ou une variable locale en T-SQL, dont l’optimiseur ne peut pas voir la valeur (OPTION (RECOMPILE) le permet).

La conversion implicite bloque une recherche

Ce que cela signifie. SQL Server a dû convertir les valeurs d'une colonne en un autre type avant de les comparer, donc il n'a pas pu faire une recherche d'index sur cette colonne et l'a scannée à la place. La cause classique est un nvarchar paramètre comparé avec une varchar colonne. Le visualiseur rapporte les avertissements de conversion « Plan de recherche » de SQL Server ; les conversions qui n'affectent que les estimations de cardinalité sont listées à part comme avertissements de l'optimiseur.

Comment le corriger. Faites en sorte que la valeur comparée soit du type de la colonne : déclarez le paramètre comme varchar, définissez explicitement le type et la longueur du paramètre dans votre code d'accès aux données au lieu de le laisser en déduire un à partir d'une chaîne, ou modifiez la colonne si elle doit vraiment être Unicode.

Recherche par clé

Ce que cela signifie. SQL Server a trouvé les lignes via un index non cluster, puis est repassé par la table une fois par ligne pour les colonnes que l'index ne contient pas (un Key Lookup, ou un RID Lookup sur un heap). Peu coûteux pour quelques lignes, coûteux pour des milliers, car chaque recherche est une lecture séparée.

Comment le corriger. Si cela concerne de nombreuses lignes, ajoutez les colonnes manquantes à l'index INCLUDE liste afin qu'elle couvre la requête, ou sélectionnez moins de colonnes. Pour quelques lignes, c'est généralement sans gravité - le plan le marque comme information, et non comme un avertissement.

Débordement vers tempdb

Ce que cela signifie. Un opérateur de tri ou de hachage a épuisé la mémoire que SQL Server avait accordée à la requête et a écrit des lignes intermédiaires dans tempdb, ce qui est beaucoup plus lent que de travailler en mémoire. C'est généralement un symptôme d'une estimation de lignes basse : la mémoire accordée était prévue pour moins de lignes que celles arrivées.

Comment le corriger. Corrigez d'abord l'estimation (voir erreur d'estimation du nombre de lignes), réduisez le nombre de lignes qui atteignent l'opérateur avec un filtre plus sélectif, ou supprimez un ORDER BY ou DISTINCT. Les versions plus récentes de SQL Server ajustent d'elles-mêmes les allocations de mémoire entre les exécutions (feedback sur l'allocation de mémoire) ; le MIN_GRANT_PERCENT hint de requête est le levier manuel.

Colonnes sans statistiques

Ce que cela signifie. SQL Server n'avait pas de statistiques sur une colonne utilisée dans un filtre ou une jointure de la requête, donc ses estimations de lignes sont des suppositions.

Comment le corriger. Assurez-vous que AUTO_CREATE_STATISTICS est activé pour la base de données, ou créez des statistiques sur les colonnes nommées avec CREATE STATISTICS.

Pas de prédicat de jointure

Ce que cela signifie. Une jointure n’a aucune condition reliant les deux entrées, donc chaque ligne d’un côté s’associe à chaque ligne de l’autre : deux tables de 1 000 lignes deviennent un million de lignes avant qu’un filtre ne s’applique. Il s’agit presque toujours d’une ON clause.

Comment le corriger. Ajoutez la condition de jointure. Si vous voulez vraiment chaque combinaison, écrivez CROSS JOIN pour que l'intention soit claire.

Objectif de lignes

Ce que cela signifie. TOP, EXISTS, IN ou OPTION (FAST n) a indiqué à SQL Server qu'il ne cherche que les toutes premières lignes ; il choisit donc un plan qui commence à rendre des résultats vite — souvent des boucles imbriquées sur un index — même s'il coûte plus cher à mener jusqu'au bout.

Comment le corriger. Habituellement rien : c'est le plan que vous voulez pour une requête top-N. Si la requête finit par lire beaucoup plus de lignes que prévu, l'objectif de lignes est la raison pour laquelle le plan apparaît ainsi ; SQL Server 2016 SP1 et versions ultérieures acceptent OPTION (USE HINT('DISABLE_OPTIMIZER_ROWGOAL')) de comparer avec le plan sans celui-ci.

Spool

Ce que cela signifie. SQL Server a stocké des lignes intermédiaires dans une table de travail (un Table Spool ou Index Spool) pour les réutiliser. C'est souvent une optimisation judicieuse, mais un index spool eager signifie que l'optimiseur construit un index temporaire à chaque exécution parce qu'un index permanent manque.

Comment le corriger. Ne vous en occupez pas, sauf si le spool représente une grande part du coût. Pour un spool d'index, créez l'index qu'il est en train de construire - ses colonnes de recherche (seek) indiquent lequel.

Autres avertissements de l'optimiseur

Ce que cela signifie. Avertissements enregistrés par le moteur qui ne correspondent pas à une catégorie ci-dessus, affichés avec la formulation propre du moteur - par exemple, l'avertissement de SQL Server concernant une allocation excessive de mémoire (la requête a réservé beaucoup plus de mémoire qu'elle n'en a utilisée, ce qui prive les requêtes concurrentes) ou une conversion de type pouvant affecter les estimations de cardinalité.

Comment le corriger. Lisez les détails de l'opérateur. Les allocations excessives proviennent généralement de lignes surestimées ou de colonnes larges varchar(max) colonnes triées ; les conversions sont corrigées de la même manière que le constat de conversion implicite.

Lire l'arborescence et le diagramme

  • Les données remontent. L'opérateur racine - celui qui retourne les lignes - est en haut. Ses enfants lui fournissent des lignes, donc les feuilles en bas sont l'endroit où les données sont lues à partir des tables et des index.
  • Partage des coûts. Le pourcentage est le coût estimé du sous-arbre de l'opérateur par rapport à l'ensemble de l'instruction, le même chiffre que rapportent SQL Server, PostgreSQL, MySQL et Oracle. Les coûts sont des unités de l'optimiseur, pas des millisecondes, et incluent tout ce qui se trouve en dessous de l'opérateur ; les plans de DuckDB utilisent le temps à la place et les plans de SQLite et ClickHouse n'ont aucun coût.
  • Estimé → réel. Dans un plan réel, chaque opérateur montre ce que l’optimiseur attendait et ce qui s’est réellement passé. Un écart de 10× ou plus est mis en évidence, car c’est là que les plans déraillent.
  • Barres ambre. Dans le diagramme, la barre sous un opérateur reflète sa part du coût et passe en ambre quand cet opérateur a un avertissement.

Le visualiseur web et l'application de bureau SQLly

Cette page et le panneau de plan dans SQLly partagent le même analyseur et moteur de détection. L'application de bureau ajoute tout ce qui nécessite une connexion en direct.

FonctionnalitéVisualiseur webSQLly desktop
Constats, arbre des opérateurs et diagrammeOuiOui
Ouvrir ou coller un plan enregistréOuiOui
Capturer les plans réels ou estimés d’un seul raccourci-Oui, depuis l'éditeur
Options EXPLAIN (ANALYZE, BUFFERS, VERBOSE…) mémorisées par connexion-Oui
Préréglage Profil qui n'exécute que des instructions SELECT-Oui
Comparer deux captures de la même requête-Oui
Ouvrir un index suggéré dans un nouvel onglet de requêteCopie uniquementOui
Parcours guidé du plan par l'IA-Oui

FAQ du visualiseur de plan de requête

Ce visualiseur de plan de requête est-il gratuit ?

Oui. Il n'y a pas d'inscription et aucune limite au nombre de plans que vous pouvez ouvrir. C'est le lecteur de plans de l'application de bureau SQLly, publié en tant qu'outil web gratuit.

Mon plan d'exécution est-il envoyé quelque part ?

Non. Le visualiseur est compilé en WebAssembly et s'exécute dans votre onglet de navigateur. Un plan que vous collez ou ouvrez est lu sur votre appareil ; il n'est jamais envoyé à un serveur, journalisé ni stocké. Les plans contiennent votre texte SQL, des noms de tables et parfois des valeurs de paramètres, ce qui n'est pas anodin.

Quels formats de plans peut-il lire ?

SQL Server ShowPlan XML (.sqlplan fichiers, SET STATISTICS XML et SET SHOWPLAN_XML sortie), PostgreSQL EXPLAIN (FORMAT JSON) avec ou sans ANALYZE, MySQL EXPLAIN FORMAT=JSON et EXPLAIN ANALYZE, MariaDB EXPLAIN FORMAT=JSON et ANALYZE FORMAT=JSON, SQLite EXPLAIN QUERY PLAN, DuckDB EXPLAIN (FORMAT JSON), ClickHouse EXPLAIN json = 1 et Oracle DBMS_XPLAN sortie. Le format est détecté automatiquement.

Capturer un plan réel exécute-t-il ma requête ?

Oui. SET STATISTICS XML, EXPLAIN ANALYZE, ANALYZE FORMAT=JSON et GATHER_PLAN_STATISTICS tous exécutent l’instruction, y compris tout INSERT, UPDATE ou DELETE. Utilisez la forme estimée (SET SHOWPLAN_XML, EXPLAIN sans ANALYZE, EXPLAIN PLAN FOR) lorsque l'instruction ne doit pas s'exécuter, ou enveloppez une modification de données dans une transaction que vous annulez.

Pourquoi ne peut-il pas lire mon plan PostgreSQL ?

Le visualiseur lit le format JSON du plan de PostgreSQL, pas le format texte par défaut. Exécutez EXPLAIN (FORMAT JSON) ou EXPLAIN (ANALYZE, FORMAT JSON) et collez le résultat. Sortie copiée directement depuis psql, y compris son QUERY PLAN et + à la fin de chaque ligne, est nettoyé automatiquement.

Pourquoi les coûts ou le nombre de lignes manquent-ils pour certains moteurs ?

Le visualiseur n'affiche que ce que le moteur rapporte. Pour SQLite, l' EXPLAIN QUERY PLAN n’a pas de coûts ni d’estimations de lignes, ClickHouse n’a pas de modèle de coût, et DuckDB n’a pas d’unités de coût, donc ces plans montrent la structure des opérateurs et les scans plutôt que les parts de coûts. Les nombres de lignes réels apparaissent seulement pour les plans capturés avec les statistiques d’exécution.

Puis-je comparer deux plans d’exécution ?

Pas dans le visualiseur web. L’application de bureau Application de bureau SQLly garde un historique des plans que vous capturez dans chaque onglet de requête et compare deux d'entre eux au choix, en signalant les opérateurs qui ont régressé, progressé, apparu ou disparu.

// oubliez le copier-coller

Capturer, lire et comparer les plans là où vous écrivez votre SQL

SQLly est un atelier SQL natif pour macOS, Windows et Linux. Appuyez sur Expliquer dans l'éditeur pour capturer un plan réel ou estimé, lire les mêmes analyses que sur cette page, et comparer deux exécutions pour prouver que votre optimisation a fonctionné.