Catégories :: Fonctions système (Informations sur la requête) , Fonctions de table

GET_QUERY_OPERATOR_STATS¶

Renvoie des statistiques sur les opérateurs de requête individuels dans une requête qui s’est terminée. Vous pouvez exécuter cette fonction pour toute requête terminée exécutée au cours des 14 derniers jours.

Vous pouvez utiliser ces informations pour comprendre la structure d’une requête et identifier les opérateurs de requête (par exemple, l’opérateur de jointure) qui causent des problèmes de performance.

Par exemple, vous pouvez utiliser ces informations pour déterminer quels opérateurs consomment le plus de ressources. Autre exemple, vous pouvez utiliser cette fonction pour identifier les jointures qui ont plus de lignes de sortie que de lignes d’entrée, ce qui peut être le signe d’une « explosion » de jointures (par exemple, un produit cartésien involontaire).

Ces statistiques sont également disponibles dans l’onglet Profil de requête dans Snowsight. La fonction GET_QUERY_OPERATOR_STATS() rend les mêmes informations disponibles via une interface programmatique.

Pour plus d’informations sur la recherche d’opérateurs de requête problématiques, voir Problèmes de requête courants identifiés par le profil de requête.

Syntaxe¶

GET_QUERY_OPERATOR_STATS( <query_id> )

Copy

Arguments¶

query_id

ID de la requête. Vous pouvez utiliser :

Un littéral de chaîne (une chaîne entourée de guillemets simples).
Une variable de session contenant un ID de requête.
La valeur de retour d’un appel à la fonction LAST_QUERY_ID.

Renvoie¶

La fonction GET_QUERY_OPERATOR_STATS est une fonction de table. Elle renvoie des lignes contenant des statistiques sur chaque opérateur de requête de la requête. Pour plus d’informations, voir les sections Notes sur l’utilisation et Sortie ci-dessous.

Notes sur l’utilisation¶

Cette fonction ne renvoie que des statistiques sur les requêtes qui ont se sont terminées.
Vous devez disposer des privilèges OPERATE ou MONITOR sur l’entrepôt où vous avez exécuté la requête.
Cette fonction fournit des statistiques détaillées sur chaque opérateur de requête utilisé dans la requête spécifiée. Les opérateurs de requête possibles comprennent :
- Aggregate : regroupe les entrées et calcule les fonctions d’agrégat.
- CartesianJoin : un type spécialisé de jointure.
- Delete : supprime un enregistrement d’une table.
- ExternalFunction : représente le traitement par une fonction externe.
- ExternalScan : représente l’accès aux données stockées dans les objets de zone de préparation.
- Filter : représente une opération qui filtre les lignes.
- Flatten : traite les enregistrements VARIANT, en les aplatissant éventuellement sur un chemin spécifié.
- Generator : génère des enregistrements à l’aide de la construction TABLE(GENERATOR(…)).
- GroupingSets : représente des constructions, telles que GROUPING SETS, ROLLUP et CUBE.
- Insert : ajoute un enregistrement à une table via une opération INSERT ou COPY.
- InternalObject : représente l’accès à un objet de données interne (par exemple, dans un Information Schema ou le résultat d’une requête précédente).
- Join : combine deux entrées sur une condition donnée.
- JoinFilter : opération de filtrage spéciale qui enlève les tuples qui peuvent être identifiés comme ne correspondant pas à l’état d’une jointure plus loin dans le plan de requête.
- Merge : effectue une opération MERGE sur une table.
- Pivot : transforme les valeurs uniques d’une colonne en plusieurs colonnes et effectue toute agrégation nécessaire.
- Result : renvoie le résultat de la requête.
- Sort : trie l’entrée sur une expression donnée.
- SortWithLimit : produit une partie de la séquence d’entrée après le tri, généralement le résultat d’une construction ORDER BY ... LIMIT ... OFFSET ....
- TableScan : représente l’accès à une table unique.
- UnionAll : procède à la concaténation de deux entrées.
- Unload : représente une opération COPY qui exporte les données d’une table vers un fichier dans une zone de préparation.
- Unpivot : fait pivoter une table en transformant des colonnes en lignes.
- Update : met à jour un enregistrement dans une table.
- ValuesClause : liste des valeurs fournies avec la clause VALUES.
- WindowFunction : calcule les fonctions de la fenêtre.
- WithClause : précède le corps de l’instruction SELECT et définit une ou plusieurs CTEs.
- WithReference : instance d’une clause WITH.
Les informations sont renvoyées sous forme de table. Chaque ligne de la table correspond à un opérateur. La ligne contient la répartition de l’exécution et les statistiques des requêtes pour cet opérateur.

La ligne peut également énumérer les attributs de l’opérateur (ceux-ci dépendent du type d’opérateur).

Les statistiques qui décomposent le temps d’exécution des requêtes sont exprimées en pourcentage du temps consommé par la requête totale.

Pour plus d’informations sur des statistiques spécifiques, voir Sortie (dans cette rubrique).
Comme cette fonction est une fonction de table, vous devez l’utiliser dans une clause FROM et vous devez la délimiter par TABLE(). Par exemple :
```
select *
    from table(get_query_operator_stats(last_query_id()));
```
Copy

Pour chaque exécution individuelle d’une requête spécifique (c’est-à-dire un UUID spécifique), cette fonction est déterministe ; elle renvoie les mêmes valeurs à chaque fois.

Toutefois, pour différentes exécutions du même texte de requête, cette fonction peut renvoyer des statistiques d’exécution différentes. Les statistiques dépendent de nombreux facteurs. Les facteurs suivants peuvent avoir un impact important sur l’exécution et donc sur les statistiques retournées par cette fonction :
- Le volume des données.
- La disponibilité de vues matérialisées, et les modifications (le cas échéant) apportées aux données depuis la dernière actualisation de ces vues matérialisées.
- La présence ou l’absence d’un clustering.
- La présence ou l’absence de données précédemment mises en cache.
- La taille de l’entrepôt virtuel.
Les valeurs peuvent également être affectées par des facteurs extérieurs à la requête et aux données de l’utilisateur. Ces facteurs sont généralement faibles. Les facteurs sont les suivants :
- Temps d’initialisation de l’entrepôt virtuel.
- Latence avec les fonctions externes.

Sortie¶

La fonction renvoie les colonnes suivantes :

Nom de la colonne	Type de données	Description
QUERY_ID	VARCHAR	ID de requête, qui est un identificateur interne, généré par le système pour l’instruction SQL.
STEP_ID	NUMBER(38, 0)	Identificateur de l’étape dans le plan de requête.
OPERATOR_ID	NUMBER(38, 0)	L’identificateur de l’opérateur. Il est unique dans la requête. Les valeurs commencent à 0.
PARENT_OPERATORS	ARRAY contenant un ou plusieurs NUMBER(38, 0)	Identificateurs des opérateurs parents de cet opérateur, ou NULL s’il s’agit de l’opérateur final du plan de requête (qui est généralement l’opérateur Résultat).
OPERATOR_TYPE	VARCHAR	Le type d’opérateur de requête (par exemple, `TableScan` ou `Filter`).
OPERATOR_STATISTICS	VARIANT contenant un OBJECT	Statistiques sur l’opérateur (par exemple, le nombre de lignes de sortie de l’opérateur).
EXECUTION_TIME_BREAKDOWN	VARIANT contenant un OBJECT	Informations sur le temps d’exécution de l’opérateur.
OPERATOR_ATTRIBUTES	VARIANT contenant un OBJECT	Informations sur l’opérateur. Ces informations dépendent du type d’opérateur.

S’il n’y a pas d’information pour la colonne spécifique de l’opérateur, la valeur est NULL.

Trois de ces colonnes contiennent des OBJECTs. Chaque objet contient des paires clé/valeur. Les tableaux ci-dessous présentent des informations sur les clés de ces tables.

OPERATOR_STATISTICS¶

Les champs dans OBJECTs pour la colonne OPERATOR_STATISTICS fournissent des informations supplémentaires sur l’opérateur. Ces informations peuvent inclure les éléments suivants :

Clé	Clé imbriquée (si applicable)	Type de données	Description
`dml`			Statistiques des requêtes Data Manipulation Language (DML) :
	`number_of_rows_inserted`	DOUBLE	Nombre de lignes insérées dans une ou plusieurs tables.
	`number_of_rows_updated`	DOUBLE	Nombre de lignes mises à jour dans une table.
	`number_of_rows_deleted`	DOUBLE	Nombre de lignes supprimées d’une table.
	`number_of_rows_unloaded`	DOUBLE	Nombre de lignes déchargées lors de l’exportation des données.
`external_functions`			Informations sur les appels à des fonctions externes. Si la valeur d’un champ, par exemple `retries_due_to_transient_errors`, est nulle, le champ n’est pas affiché.
	`total_invocations`	DOUBLE	Le nombre de fois qu’une fonction externe a été appelée. (Cela peut être différent du nombre d’appels de fonctions externes dans le texte de l’instruction SQL en raison du nombre de lots dans lesquels les lignes sont divisées, du nombre de tentatives (en cas de problèmes de réseau transitoires), etc.)
	`rows_sent`	DOUBLE	Nombre de lignes envoyées aux fonctions externes.
	`rows_received`	DOUBLE	Nombre de lignes reçues en retour de fonctions externes.
	`bytes_sent (x-region)`	DOUBLE	Le nombre d’octets envoyés aux fonctions externes. Si la clé inclut `(x-region)`, les données ont été envoyées entre plusieurs régions (ce qui peut avoir un impact sur la facturation).
	`bytes_received (x-region)`	DOUBLE	Nombre d’octets reçus depuis des fonctions externes. Si la clé inclut `(x-region)`, les données ont été envoyées entre plusieurs régions (ce qui peut avoir un impact sur la facturation).
	`retries_due_to_transient_errors`	DOUBLE	Le nombre de tentatives en raison d’erreurs transitoires.
	`average_latency_per_call`	DOUBLE	La durée moyenne par appel en millisecondes entre le moment où Snowflake a envoyé les données et reçu les données renvoyées.
	`http_4xx_errors`	INTEGER	Nombre total de requêtes HTTP ayant renvoyé un code de statut 4xx.
	`http_5xx_errors`	INTEGER	Nombre total de requêtes HTTP ayant renvoyé un code de statut 5xx.
	`average_latency`	DOUBLE	Temps de latence moyen pour les requêtes HTTP réussies.
	`avg_throttle_latency_overhead`	DOUBLE	Frais généraux moyens par requête réussie en raison d’un ralentissement causé par la limitation (HTTP 429).
	`batches_retried_due_to_throttling`	DOUBLE	Nombre de lots qui ont fait l’objet de nouvelles tentatives en raison d’erreurs HTTP 429.
	`latency_per_successful_call_(p50)`	DOUBLE	50e percentile de latence pour les requêtes HTTP réussies. 50 pour cent de toutes les requêtes acceptées ont été traitées en moins de temps.
	`latency_per_successful_call_(p90)`	DOUBLE	90e percentile de latence pour les requêtes HTTP réussies. 90 pour cent de toutes les requêtes acceptées ont été traitées en moins de temps.
	`latency_per_successful_call_(p95)`	DOUBLE	95e percentile de latence pour les requêtes HTTP réussies. 95 pour cent de toutes les requêtes réussies ont été traitées en moins de temps.
	`latency_per_successful_call_(p99)`	DOUBLE	99e percentile de latence pour les requêtes HTTP réussies. 99 pour cent de toutes les requêtes réussies ont été traitées en moins de temps.
`input_rows`		INTEGER	Le nombre de lignes d’entrée. Cela peut manquer pour un opérateur qui n’a pas de bords d’entrée provenant d’autres opérateurs.
`io`			Informations sur les opérations d’entrée/sortie effectuées pendant la requête.
	`scan_progress`	DOUBLE	Pourcentage de données analysées pour une table donnée jusqu’à présent.
	`bytes_scanned`	DOUBLE	Nombre d’octets analysés jusqu’à présent.
	`percentage_scanned_from_cache`	DOUBLE	Pourcentage de données analysées à partir du cache du disque local.
	`bytes_written`	DOUBLE	Octets écrits (par exemple, lors du chargement dans une table).
	`bytes_written_to_result`	DOUBLE	Octets écrits dans un objet de résultat. Par exemple, `select * from . . .` produirait un jeu de résultats sous forme de tableau représentant chaque champ de la sélection. En général, l’objet de résultats représente tout ce qui est produit comme résultat de la requête, et `bytes_written_to_result` représente la taille du résultat retourné.
	`bytes_read_from_result`	DOUBLE	Octets lus à partir d’un objet de résultat.
	`external_bytes_scanned`	DOUBLE	Octets lus à partir d’un objet externe (par exemple, une zone de préparation).
`network`	`network_bytes`	DOUBLE	Quantité de données envoyées sur le réseau.
`output_rows`		INTEGER	Le nombre de lignes de sortie. Cela peut manquer pour l’opérateur qui renvoie les résultats à l’utilisateur (qui est généralement l’opérateur RESULT).
`pruning`			Informations sur le nettoyage de la table.
	`partitions_scanned`	DOUBLE	Nombre de partitions analysées jusqu’à présent.
	`partitions_total`	DOUBLE	Nombre total de partitions dans une table donnée.
`spilling`			Informations sur l’utilisation du disque pour les opérations où les résultats intermédiaires ne rentrent pas dans la mémoire.
	`bytes_spilled_remote_storage`	DOUBLE	Volume de données déversées sur le disque distant.
	`bytes_spilled_local_storage`	DOUBLE	Volume de données déversées sur le disque local.
`extension_functions`			Informations sur les appels aux fonctions d’extension. Si la valeur d’un champ est nulle, le champ n’est pas affiché.
	`Java UDF handler load time`	DOUBLE	le temps de chargement du gestionnaire d’UDF Java.
	`Total Java UDF handler invocations`	DOUBLE	le nombre de fois où le gestionnaire d’UDF Java est appelé.
	`Max Java UDF handler execution time`	DOUBLE	la durée maximale d’exécution du gestionnaire d’UDF Java.
	`Avg Java UDF handler execution time`	DOUBLE	le temps moyen d’exécution du gestionnaire d’UDF Java.
	`Java UDTF process() invocations`	DOUBLE	le nombre de fois où la méthode de traitement des UDTF Java a été appelée.
	`Java UDTF process() execution time`	DOUBLE	le temps nécessaire à l’exécution du traitement des UDTF Java.
	`Avg Java UDTF process() execution time`	DOUBLE	le temps moyen d’exécution du traitement des UDTF Java.
	`Java UDTF's constructor invocations`	DOUBLE	le nombre de fois où le constructeur d’UDTF Java a été appelé.
	`Java UDTF's constructor execution time`	DOUBLE	le temps d’exécution du constructeur d’UDTF Java.
	`Avg Java UDTF's constructor execution time`	DOUBLE	le temps moyen d’exécution du constructeur d’UDTF Java.
	`Java UDTF endPartition() invocations`	DOUBLE	le nombre de fois où la méthode endPartition d’UDTF Java a été appelée.
	`Java UDTF endPartition() execution time`	DOUBLE	le temps nécessaire à l’exécution de la méthode endPartition d’UDTF Java.
	`Avg Java UDTF endPartition() execution time`	DOUBLE	le temps moyen d’exécution de la méthode endPartition d’UDTF Java.
	`Max Java UDF dependency download time`	DOUBLE	la durée maximale de téléchargement des dépendances d’UDF Java.
	`Max JVM memory usage`	DOUBLE	le pic d’utilisation de la mémoire tel que rapporté par le JVM.
	`Java UDF inline code compile time in ms`	DOUBLE	le temps de compilation pour le code en ligne d’UDF Java.
	`Total Python UDF handler invocations`	DOUBLE	le nombre de fois où le gestionnaire d’UDF Python a été appelé.
	`Total Python UDF handler execution time`	DOUBLE	le temps d’exécution total du gestionnaire d’UDF Python.
	`Avg Python UDF handler execution time`	DOUBLE	le temps moyen d’exécution du gestionnaire d’UDF Python.
	`Python sandbox max memory usage`	DOUBLE	l’utilisation maximale de la mémoire par l’environnement sandbox de Python.
	`Avg Python env creation time: Download and install packages`	DOUBLE	le temps moyen nécessaire pour créer l’environnement Python, y compris le téléchargement et l’installation des paquets.
	`Conda solver time`	DOUBLE	le temps nécessaire à l’exécution du solveur Conda pour résoudre les paquets Python.
	`Conda env creation time`	DOUBLE	le temps nécessaire à la création de l’environnement Python.
	`Python UDF initialization time`	DOUBLE	le temps nécessaire à l’initialisation de l’UDF Python.
	`Number of external file bytes read for UDFs`	DOUBLE	le nombre d’octets de fichiers externes lus pour des UDFs.
	`Number of external files accessed for UDFs`	DOUBLE	le nombre de fichiers externes accédés pour des UDFs.

EXECUTION_TIME_BREAKDOWN¶

Les champs dans OBJECTs pour la colonne EXECUTION_TIME_BREAKDOWN sont présentés ci-dessous.

Clé	Type de données	Description
`overall_percentage`	DOUBLE	Pourcentage du temps total de requête passé par cet opérateur.
`initialization`	DOUBLE	Temps passé à configurer le traitement de la requête.
`processing`	DOUBLE	Temps passé à traiter les données par le CPU.
`synchronization`	DOUBLE	Temps passé à synchroniser les activités entre les processus participants.
`local_disk_io`	DOUBLE	Temps pendant lequel le traitement a été bloqué en attendant l’accès au disque local.
`remote_disk_io`	DOUBLE	Temps pendant lequel le traitement a été bloqué en attendant l’accès au disque distant.
`network_communication`	DOUBLE	Temps pendant lequel le traitement attendait le transfert de données du réseau.

OPERATOR_ATTRIBUTES¶

Chaque ligne de sortie décrit un opérateur dans la requête. Le tableau ci-dessous présente les types d’opérateurs possibles (par exemple, l’opérateur Filtre). Pour chaque type d’opérateur, le tableau indique les attributs possibles (par exemple, l’expression utilisée pour filtrer les lignes).

Les attributs de l’opérateur sont stockés dans la colonne OPERATOR_ATTRIBUTES, qui est de type VARIANT et contient un OBJECT. L’OBJECT contient des paires clé/valeur. Chaque clé correspond à un attribut de l’opérateur.

Nom de l’opérateur	Clé	Type de données	Description
`Aggregate`
	`functions`	ARRAY de VARCHAR	Liste des fonctions calculées.
	`grouping_keys`	ARRAY de VARCHAR	L’expression group-by.
`CartesianJoin`
	`additional_join_condition`	VARCHAR	Expression de jointure de non-égalité.
	`equality_join_condition`	VARCHAR	Expression de jointure d’égalité.
	`join_type`	VARCHAR	Type de jointure (INNER).
`Delete`	`table_name`	VARCHAR	Nom de la table mise à jour.
`ExternalScan`
	`stage_name`	VARCHAR	Le nom de la zone de préparation à partir de laquelle les données sont lues.
	`stage_type`	VARCHAR	Type de zone de préparation.
`Filter`	`filter_condition`	VARCHAR	Expression utilisée pour filtrer les données.
`Flatten`	`input`	VARCHAR	Expression d’entrée utilisée pour aplatir les données.
`Generator`
	`row_count`	NUMBER	Valeur du paramètre d’entrée ROWCOUNT.
	`time_limit`	NUMBER	Valeur du paramètre d’entrée TIMELIMIT.
`GroupingSets`
	`functions`	ARRAY de VARCHAR	Liste des fonctions calculées.
	`key_sets`	ARRAY de VARCHAR	Liste des ensembles de groupement.
`Insert`
	`input_expression`	VARCHAR	Expressions insérées.
	`table_names`	ARRAY de VARCHAR	Liste des noms de tables dans lesquelles les enregistrements sont ajoutés.
`InternalObject`	`object_name`	VARCHAR	Nom de l’objet auquel on accède.
`Join`
	`additional_join_condition`	VARCHAR	Expression de jointure de non-égalité.
	`equality_join_condition`	VARCHAR	Expression de jointure d’égalité.
	`join_type`	VARCHAR	Type de jointure (INNER, OUTER, LEFT JOIN, etc.).
`JoinFilter`	`join_id`	NUMBER	Identifiant d’opération de la jointure utilisée pour identifier les tuples qui peuvent être filtrées.
`Merge`	`table_name`	VARCHAR	Nom de la table mise à jour.
`Pivot`
	`grouping_keys`	ARRAY de VARCHAR	Colonnes restantes sur lesquelles les résultats sont agrégés.
	`pivot_column`	ARRAY de VARCHAR	Colonnes résultantes des valeurs pivot.
`Result`	`expressions`	ARRAY de VARCHAR	Liste des expressions produites.
`Sort`	`sort_keys`	ARRAY de VARCHAR	Expression définissant l’ordre de tri.
`SortWithLimit`
	`offset`	NUMBER	Position dans la séquence ordonnée à partir de laquelle les tuples produits sont émis.
	`rows`	NUMBER	Nombre de lignes produites.
	`sort_keys`	ARRAY de VARCHAR	Expression définissant l’ordre de tri.
`TableScan`
	`columns`	ARRAY de VARCHAR	Liste des colonnes analysées.
	`extracted_variant_paths`	ARRAY de VARCHAR	Liste des chemins extraits des colonnes de variantes.
	`table_alias`	VARCHAR	Alias de la table à laquelle on accède.
	`table_name`	VARCHAR	Nom de la table à laquelle on accède.
`Unload`	`location`	VARCHAR	Zone de préparation où les données sont sauvegardées.
`Unpivot`	`expressions`	ARRAY de VARCHAR	Colonnes de sortie de la requête de dépivotage.
`Update`	`table_name`	VARCHAR	Nom de la table mise à jour.
`ValuesClause`
	`value_count`	NUMBER	Nombre de valeurs produites.
	`values`	VARCHAR	Liste de valeurs.
`WindowFunction`	`functions`	ARRAY de VARCHAR	Liste des fonctions calculées.
`WithClause`	`name`	VARCHAR	Alias de la clause WITH.

Si un opérateur n’apparaît pas, aucun attribut n’est produit et la valeur est signalée comme {}.

Note

Les opérateurs suivants n’ont pas d’attributs d’opérateur et ne sont donc pas inclus dans la table de OPERATOR_ATTRIBUTES :
- UnionAll
- ExternalFunction

Exemples¶

Récupération de données sur une seule requête¶

Cet exemple montre les statistiques d’une instruction SELECT qui joint deux petites tables.

Exécutez l’instruction SELECT :

select x1.i, x2.i
    from x1 inner join x2 on x2.i = x1.i
    order by x1.i, x2.i;

Copy

Obtenez l’ID de requête :

set lqid = (select last_query_id());

Copy

Appelez GET_QUERY_OPERATOR_STATS() pour obtenir des statistiques sur les opérateurs individuels de la requête :

select * from table(get_query_operator_stats($lqid));
+--------------------------------------+---------+-------------+--------------------+---------------+-----------------------------------------+-----------------------------------------------+----------------------------------------------------------------------+
| QUERY_ID                             | STEP_ID | OPERATOR_ID | PARENT_OPERATORS   | OPERATOR_TYPE | OPERATOR_STATISTICS                     | EXECUTION_TIME_BREAKDOWN                      | OPERATOR_ATTRIBUTES                                                  |
|--------------------------------------+---------+-------------+--------------------+---------------+-----------------------------------------+-----------------------------------------------+----------------------------------------------------------------------|
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           0 |               NULL | Result        | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "input_rows": 64                      |   "overall_percentage": 0.000000000000000e+00 |   "expressions": [                                                   |
|                                      |         |             |                    |               | }                                       | }                                             |     "X1.I",                                                          |
|                                      |         |             |                    |               |                                         |                                               |     "X2.I"                                                           |
|                                      |         |             |                    |               |                                         |                                               |   ]                                                                  |
|                                      |         |             |                    |               |                                         |                                               | }                                                                    |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           1 |              [ 0 ] | Sort          | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "input_rows": 64,                     |   "overall_percentage": 0.000000000000000e+00 |   "sort_keys": [                                                     |
|                                      |         |             |                    |               |   "output_rows": 64                     | }                                             |     "X1.I ASC NULLS LAST",                                           |
|                                      |         |             |                    |               | }                                       |                                               |     "X2.I ASC NULLS LAST"                                            |
|                                      |         |             |                    |               |                                         |                                               |   ]                                                                  |
|                                      |         |             |                    |               |                                         |                                               | }                                                                    |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           2 |              [ 1 ] | Join          | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "input_rows": 128,                    |   "overall_percentage": 0.000000000000000e+00 |   "equality_join_condition": "(X2.I = X1.I)",                        |
|                                      |         |             |                    |               |   "output_rows": 64                     | }                                             |   "join_type": "INNER"                                               |
|                                      |         |             |                    |               | }                                       |                                               | }                                                                    |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           3 |              [ 2 ] | TableScan     | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "io": {                               |   "overall_percentage": 0.000000000000000e+00 |   "columns": [                                                       |
|                                      |         |             |                    |               |     "bytes_scanned": 1024,              | }                                             |     "I"                                                              |
|                                      |         |             |                    |               |     "percentage_scanned_from_cache": 1, |                                               |   ],                                                                 |
|                                      |         |             |                    |               |     "scan_progress": 1                  |                                               |   "table_name": "MY_DB.MY_SCHEMA.X2" |
|                                      |         |             |                    |               |   },                                    |                                               | }                                                                    |
|                                      |         |             |                    |               |   "output_rows": 64,                    |                                               |                                                                      |
|                                      |         |             |                    |               |   "pruning": {                          |                                               |                                                                      |
|                                      |         |             |                    |               |     "partitions_scanned": 1,            |                                               |                                                                      |
|                                      |         |             |                    |               |     "partitions_total": 1               |                                               |                                                                      |
|                                      |         |             |                    |               |   }                                     |                                               |                                                                      |
|                                      |         |             |                    |               | }                                       |                                               |                                                                      |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           4 |              [ 2 ] | JoinFilter    | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "input_rows": 64,                     |   "overall_percentage": 0.000000000000000e+00 |   "join_id": "2"                                                     |
|                                      |         |             |                    |               |   "output_rows": 64                     | }                                             | }                                                                    |
|                                      |         |             |                    |               | }                                       |                                               |                                                                      |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           5 |              [ 4 ] | TableScan     | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "io": {                               |   "overall_percentage": 0.000000000000000e+00 |   "columns": [                                                       |
|                                      |         |             |                    |               |     "bytes_scanned": 1024,              | }                                             |     "I"                                                              |
|                                      |         |             |                    |               |     "percentage_scanned_from_cache": 1, |                                               |   ],                                                                 |
|                                      |         |             |                    |               |     "scan_progress": 1                  |                                               |   "table_name": "MY_DB.MY_SCHEMA.X1" |
|                                      |         |             |                    |               |   },                                    |                                               | }                                                                    |
|                                      |         |             |                    |               |   "output_rows": 64,                    |                                               |                                                                      |
|                                      |         |             |                    |               |   "pruning": {                          |                                               |                                                                      |
|                                      |         |             |                    |               |     "partitions_scanned": 1,            |                                               |                                                                      |
|                                      |         |             |                    |               |     "partitions_total": 1               |                                               |                                                                      |
|                                      |         |             |                    |               |   }                                     |                                               |                                                                      |
|                                      |         |             |                    |               | }                                       |                                               |                                                                      |
+--------------------------------------+---------+-------------+--------------------+---------------+-----------------------------------------+-----------------------------------------------+----------------------------------------------------------------------+

Copy

Identifier les opérateurs d”« explosion » de jonctions¶

L’exemple suivant montre comment utiliser GET_QUERY_OPERATOR_STATS pour examiner une requête complexe. Cet exemple recherche les opérateurs dans une requête qui produisent beaucoup plus de lignes que celles qui ont été entrées dans cet opérateur.

Il s’agit de la requête à analyser :

select *
from t1
    join t2 on t1.a = t2.a
    join t3 on t1.b = t3.b
    join t4 on t1.c = t4.c
;

Copy

Obtenez l’ID de la requête précédente :

set lid = last_query_id();

Copy

La requête suivante montre le rapport entre les lignes de sortie et les lignes d’entrée pour chacun des opérateurs de jointure de la requête.

select
        operator_id,
        operator_attributes,
        operator_statistics:output_rows / operator_statistics:input_rows as row_multiple
    from table(get_query_operator_stats($lid))
    where operator_type = 'Join'
    order by step_id, operator_id;

+---------+-------------+--------------------------------------------------------------------------+---------------+
| STEP_ID | OPERATOR_ID | OPERATOR_ATTRIBUTES                                                      | ROW_MULTIPLE  |
+---------+-------------+--------------------------------------------------------------------------+---------------+
|       1 |           1 | {  "equality_join_condition": "(T4.C = T1.C)",   "join_type": "INNER"  } |  49.969249692 |
|       1 |           3 | {  "equality_join_condition": "(T3.B = T1.B)",   "join_type": "INNER"  } | 116.071428571 |
|       1 |           5 | {  "equality_join_condition": "(T2.A = T1.A)",   "join_type": "INNER"  } |  12.20657277  |
+---------+-------------+--------------------------------------------------------------------------+---------------+

Copy

Après avoir identifié les explosions de jonctions, vous pouvez examiner chaque condition de jointure pour vérifier que la condition est correcte.