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>

Copy

Paramètres¶

statement

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

USING output_format

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.
`parentOperators`	Tableau d’identificateurs pour les nœuds parents 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 le nettoyage 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 le nettoyage 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.
Si l’un des objets de la base de données dans l’instruction EXPLAIN est un objet INFORMATION_SCHEMA, l’instruction échoue avec l’erreur EXPLAIN command has insufficient privilege on object <objName>.

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);

Copy

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   | parentOperators | 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 |
+------+------+-----------------+-------------+------------------------------+-------+--------------------------+-----------------+--------------------+---------------+

Copy

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} |
|                                                                                                                                    |
+------------------------------------------------------------------------------------------------------------------------------------+

Copy

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,"parentOperators":[0],"operation":"InnerJoin","expressions":["joinKey: (Z2.ID = Z1.ID)"]},{"id":2,"parentOperators":[1],"operation":"TableScan","objects":["TESTDB.TEMPORARY_DOC_TEST.Z2"],"expressions":["ID"],"partitionsAssigned":1,"partitionsTotal":1,"bytesAssigned":512},{"id":3,"parentOperators":[1],"operation":"JoinFilter","expressions":["joinKey: (Z2.ID = Z1.ID)"]},{"id":4,"parentOperators":[3],"operation":"TableScan","objects":["TESTDB.TEMPORARY_DOC_TEST.Z1"],"expressions":["ID"],"partitionsAssigned":1,"partitionsTotal":1,"bytesAssigned":512}]]} |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Copy