EXPLAIN

Renvoie le plan d’exécution logique pour l’instruction SQL spécifiée.

Un plan d’explication montre les opérations (par exemple, les analyses de table et les jointures) que Snowflake effectuerait pour exécuter la requête.

Voir aussi :

SYSTEM$EXPLAIN_PLAN_JSON , SYSTEM$EXPLAIN_JSON_TO_TEXT , EXPLAIN_JSON

Syntaxe

EXPLAIN [ USING { TABULAR | JSON | TEXT } ] <statement>

Paramètres

instruction

Il s’agit de l’instruction SQL pour laquelle vous souhaitez le plan d’explication.

USING format_sortie

Cette clause facultative spécifie le format de sortie. Les formats de sortie possibles sont :

  • JSON: Une sortie JSON est plus facile à stocker dans une table et une requête.

  • TABULAR : la sortie tabulaire est généralement plus lisible par l’homme qu’une sortie JSON.

  • TEXT : la sortie de texte formaté est généralement plus lisible par l’homme qu’une sortie JSON.

La valeur par défaut est TABULAR.

Sortie

La sortie contient les informations suivantes :

Colonne

Description

step

La plupart des requêtes contiennent une seule étape, mais certaines sont exécutées en plusieurs étapes distinctes. Cette colonne indique à quelle étape l’opération appartient.

id

Identifiant unique attribué à chaque opération dans le plan de requête.

parent

Identifiant du parent de l’opération. Dans le profil de requête, un parent est affiché au-dessus de son enfant avec un lien reliant les deux.

operation

Nom de l’opération, par exemple Résultat, Filtre, TableScan, Joindre, etc.

objects

Nom de l’objet référencé par une opération d’analyse de table, par exemple table, vue matérialisée ou vue sécurisée.

alias

Alias d’un objet référencé, si l’objet a reçu un alias dans la requête.

expressions

Liste d’expressions pertinentes pour l’opération en cours telles que les filtres, les prédicats de jointure, les projections, les agrégations, etc.

totalPartitions

Nombre total de micropartitions dans l’objet de base de données référencé.

assignedPartitions

Le nombre de partitions de l’objet référencé qui restent après l’élagage au moment de la compilation, c’est-à-dire le nombre de partitions qui peuvent être analysées par la requête.

assignedBytes

Le nombre d’octets contenus dans les partitions attribuées.

Notes sur l’utilisation

  • EXPLAIN compile l’instruction SQL, mais ne l’exécute pas, donc EXPLAIN ne nécessite pas d’entrepôt en cours d’exécution.

  • Bien que EXPLAIN ne consomme aucun crédit de calcul, la compilation de la requête consomme des crédits de service cloud, tout comme les autres opérations de métadonnées.

  • Pour post-traiter la sortie de cette commande, vous pouvez :

    • Utiliser la fonction RESULT_SCAN , qui traite la sortie comme une table qui peut être interrogée.

    • Générer la sortie au format JSON et insérer la sortie formatée JSON dans un tableau pour une analyse ultérieure. Si vous stockez la sortie au format JSON, vous pouvez utiliser la fonction SYSTEM$EXPLAIN_JSON_TO_TEXT ou EXPLAIN_JSON pour convertir le JSON dans un format plus lisible par l’homme (texte tabulaire ou formaté).

  • Les valeurs Partitionsaffectées et Octetsaffectés sont des estimations de limite supérieure pour l’exécution des requêtes. Les optimisations d’exécution telles que l’élagage de jointure peuvent réduire le nombre de partitions et d’octets analysés pendant l’exécution de la requête.

  • Le plan EXPLAIN est le plan d’explication « logique ». Il montre les opérations qui seront effectuées et leur relation logique les unes avec les autres. L’ordre d’exécution réel des opérations dans le plan ne correspond pas nécessairement à l’ordre logique affiché par le plan.

Exemples

Cet exemple montre la sortie EXPLAIN pour une requête simple sur deux petites tables.

Créez les tables :

CREATE TABLE Z1 (ID INTEGER);
CREATE TABLE Z2 (ID INTEGER);
CREATE TABLE Z3 (ID INTEGER);

Générez le plan EXPLAIN au format tabulaire pour la requête :

EXPLAIN USING TABULAR SELECT Z1.ID, Z2.ID 
    FROM Z1, Z2
    WHERE Z2.ID = Z1.ID;
+------+----+--------+-------------+------------------------------+-------+--------------------------+-----------------+--------------------+---------------+
| step | id | parent | operation   | objects                      | alias | expressions              | partitionsTotal | partitionsAssigned | bytesAssigned |
|------+----+--------+-------------+------------------------------+-------+--------------------------+-----------------+--------------------+---------------|
| NULL | NULL |   NULL | GlobalStats | NULL                         | NULL  | NULL                     |               2 |                  2 |          1024 |
|    1 |  0 |   NULL | Result      | NULL                         | NULL  | Z1.ID, Z2.ID             |            NULL |               NULL |          NULL |
|    1 |  1 |      0 | InnerJoin   | NULL                         | NULL  | joinKey: (Z2.ID = Z1.ID) |            NULL |               NULL |          NULL |
|    1 |  2 |      1 | TableScan   | TESTDB.TEMPORARY_DOC_TEST.Z2 | NULL  | ID                       |               1 |                  1 |           512 |
|    1 |  3 |      1 | JoinFilter  | NULL                         | NULL  | joinKey: (Z2.ID = Z1.ID) |            NULL |               NULL |          NULL |
|    1 |  4 |      3 | TableScan   | TESTDB.TEMPORARY_DOC_TEST.Z1 | NULL  | ID                       |               1 |                  1 |           512 |
+------+----+--------+-------------+------------------------------+-------+--------------------------+-----------------+--------------------+---------------+

Générez le plan EXPLAIN pour la requête sous forme de texte formaté :

EXPLAIN USING TEXT SELECT Z1.ID, Z2.ID 
    FROM Z1, Z2
    WHERE Z2.ID = Z1.ID;
+------------------------------------------------------------------------------------------------------------------------------------+
| content                                                                                                                            |
|------------------------------------------------------------------------------------------------------------------------------------|
| GlobalStats:                                                                                                                       |
|     partitionsTotal=2                                                                                                              |
|     partitionsAssigned=2                                                                                                           |
|     bytesAssigned=1024                                                                                                             |
| Operations:                                                                                                                        |
| 1:0     ->Result  Z1.ID, Z2.ID                                                                                                     |
| 1:1          ->InnerJoin  joinKey: (Z2.ID = Z1.ID)                                                                                 |
| 1:2               ->TableScan  TESTDB.TEMPORARY_DOC_TEST.Z2  ID  {partitionsTotal=1, partitionsAssigned=1, bytesAssigned=512}      |
| 1:3               ->JoinFilter  joinKey: (Z2.ID = Z1.ID)                                                                           |
| 1:4                    ->TableScan  TESTDB.TEMPORARY_DOC_TEST.Z1  ID  {partitionsTotal=1, partitionsAssigned=1, bytesAssigned=512} |
|                                                                                                                                    |
+------------------------------------------------------------------------------------------------------------------------------------+

Générez le plan EXPLAIN pour la requête en tant que JSON :

EXPLAIN USING JSON SELECT Z1.ID, Z2.ID 
    FROM Z1, Z2
    WHERE Z2.ID = Z1.ID;
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| content                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| {"GlobalStats":{"partitionsTotal":2,"partitionsAssigned":2,"bytesAssigned":1024},"Operations":[[{"id":0,"operation":"Result","expressions":["Z1.ID","Z2.ID"]},{"id":1,"parent":0,"operation":"InnerJoin","expressions":["joinKey: (Z2.ID = Z1.ID)"]},{"id":2,"parent":1,"operation":"TableScan","objects":["TESTDB.TEMPORARY_DOC_TEST.Z2"],"expressions":["ID"],"partitionsAssigned":1,"partitionsTotal":1,"bytesAssigned":512},{"id":3,"parent":1,"operation":"JoinFilter","expressions":["joinKey: (Z2.ID = Z1.ID)"]},{"id":4,"parent":3,"operation":"TableScan","objects":["TESTDB.TEMPORARY_DOC_TEST.Z1"],"expressions":["ID"],"partitionsAssigned":1,"partitionsTotal":1,"bytesAssigned":512}]]} |
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+