Kategorien:: Systemfunktionen (Abfrageinformationen), Tabellenfunktionen

GET_QUERY_OPERATOR_STATS¶

Gibt Statistiken zu einzelnen Abfrageoperatoren innerhalb einer abgeschlossenen Abfrage zurück. Sie können diese Funktion für jede abgeschlossene Abfrage ausführen, die in den letzten 14 Tagen ausgeführt wurde.

You can use this information to understand the structure of a query and identify query operators — for example, the join operator — that cause performance problems.

For example, you can use this information to determine which operators are consuming the most resources. As another example, you can use this function to identify joins that have more output rows than input rows, which can be a sign of an „exploding“ join; for example, an unintended Cartesian product.

Diese Statistiken sind auch auf der Registerkarte Query Profile von Snowsight verfügbar. Die Funktion GET_QUERY_OPERATOR_STATS() stellt dieselben Informationen auch über eine programmgesteuerte Schnittstelle zur Verfügung.

Weitere Informationen zum Auffinden problematischer Abfrageoperatoren finden Sie unter Typische, von Query Profile identifizierte Abfrageprobleme.

Syntax¶

GET_QUERY_OPERATOR_STATS( <query_id> )

Copy

Argumente¶

query_id

ID einer Abfrage. Sie können dafür Folgendes verwenden:

Ein Zeichenfolgenliteral (eine in einfache Anführungszeichen eingeschlossene Zeichenfolge)
Eine Sitzungsvariable, die eine Abfrage-ID enthält
Den Rückgabewert der Funktion LAST_QUERY_ID

Rückgabewerte¶

Die Funktion GET_QUERY_OPERATOR_STATS ist eine Tabellenfunktion. Sie gibt Zeilen mit Statistiken zu jedem Abfrageoperator in der Abfrage zurück. Weitere Informationen dazu finden Sie unten in den Abschnitten Nutzungshinweise und Ausgabe.

Nutzungshinweise¶

This function returns statistics only for queries that have completed.
Sie müssen über die Berechtigungen OPERATE oder MONITOR für das Warehouse verfügen, in dem Sie die Abfrage ausgeführt haben.
This function provides detailed statistics about each query operator used in the specified query. The following list shows the possible query operators:
- Aggregate: Gruppiert die Eingabe und berechnet Aggregatfunktionen.
- CartesianJoin: Eine spezieller Typ einer Join-Verknüpfung.
- Delete: Entfernt einen Datensatz aus einer Tabelle.
- ExternalFunction: Repräsentiert die Verarbeitung durch eine externe Funktion.
- ExternalScan: Repräsentiert den Zugriff auf Daten, die in Stagingobjekten gespeichert sind.
- Filter: Repräsentiert eine Operation, mit der Datensätze gefiltert werden.
- Flatten: Verarbeitet VARIANT-Datensätze und speichert eine vereinfachte Version ggf. in einem angegebenen Pfad.
- Generator: Generates records by using the TABLE(GENERATOR(…)) construct.
- GroupingSets: Represents constructs, such as GROUPING SETS, ROLLUP, and CUBE.
- Insert: Fügt einen Datensatz entweder durch eine INSERT- oder eine COPY-Operation zu einer Tabelle hinzu.
- InternalObject: Represents access to an internal data object; for example, in an Information Schema or the result of a previous query.
- Join: Kombiniert zwei Eingaben unter einer bestimmten Bedingung.
- JoinFilter: Spezielle Filteroperation, bei der Tupel entfernt werden, bei denen festgestellt wurde, dass sie weiter im Abfrageplan möglicherweise nicht mit der Bedingung eines Join übereinstimmen werden.
- Merge: Führt eine MERGE-Operation für eine Tabelle aus.
- Pivot: Transformiert eindeutige Werte aus einer Spalte in mehrere Spalten und führt alle erforderlichen Aggregationen aus.
- Result: Gibt das Abfrageergebnis zurück.
- Sort: Sortiert die Eingabe anhand eines gegebenen Ausdrucks.
- SortWithLimit: Erstellt nach der Sortierung einen Teil der Eingabesequenz, normalerweise das Ergebnis eines ORDER BY ... LIMIT ... OFFSET ...-Konstrukts.
- TableScan: Repräsentiert den Zugriff auf eine einzelne Tabelle.
- UnionAll: Verkettet zwei Eingaben.
- Unload: Repräsentiert eine COPY-Operation, bei der Daten aus einer Tabelle in eine Datei im Stagingbereich exportiert werden.
- Unpivot: Rotiert eine Tabelle, indem Spalten in Zeilen verwandelt werden.
- Update: Aktualisiert einen Datensatz in einer Tabelle.
- ValuesClause: Liste der Werte, die mit der VALUES-Klausel bereitgestellt wurden.
- WindowFunction: Berechnet Fensterfunktionen.
- WithClause: Steht vor dem Textkörper (Body) der SELECT-Anweisung und definiert eine oder mehrere CTEs.
- WithReference: Instanz einer WITH-Klausel.
Die Informationen werden in Form einer Tabelle zurückgegeben. Jede Zeile in der Tabelle entspricht einem Operator. Die Zeile enthält die Ausführungsaufschlüsselung und die Abfragestatistik für diesen Operator.

Die Zeile kann auch Operatorattribute enthalten (diese hängen vom Typ des Operators ab).

Statistics that break down query execution time are expressed as a percentage of the total query execution time.

Weitere Informationen zu bestimmten Statistiken finden Sie unter Ausgabe (unter diesem Thema).
Da diese Funktion eine Tabellenfunktion ist, müssen Sie sie in einer FROM-Klausel verwenden und in TABLE() einschließen. Beispiel:
```
SELECT * FROM TABLE(GET_QUERY_OPERATOR_STATS(last_query_id()));
```
Copy

Bei jeder einzelne Ausführung einer bestimmten Abfrage (d. h. einer spezifischen UUID) ist diese Funktion deterministisch, d. h. sie gibt jedes Mal dieselben Werte zurück.

Bei verschiedenen Ausführungen desselben Abfragetextes kann diese Funktion jedoch unterschiedliche Laufzeitstatistiken zurückgeben. Die Statistiken hängen von vielen Faktoren ab. Die folgenden Faktoren können einen großen Einfluss auf die Ausführung dieser Funktion und damit auf die von der Funktion zurückgegebenen Statistiken haben:
- Datenvolumen
- Verfügbarkeit von materialisierten Ansichten und die Änderungen (falls vorhanden) an den Daten seit der letzten Aktualisierung dieser materialisierten Ansichten.
- Vorhandensein oder Fehlen von Clustering
- Vorhandensein oder Fehlen von zuvor zwischengespeicherten Daten
- Größe des virtuellen Warehouses
Die Werte können auch durch Faktoren außerhalb der Abfrage und der Daten des Benutzers beeinflusst werden. Die Auswirkungen dieser Faktoren sind in der Regel gering. Zu diesen Faktoren zählen:
- Initialisierungszeit des virtuellen Warehouses
- Latenz bei externen Funktionen

Ausgabe¶

Die Funktion gibt die folgenden Spalten zurück:

Column name	Data type	Beschreibung
QUERY_ID	VARCHAR	Die Abfrage-ID ist ein interner, vom System generierter Bezeichner für die SQL-Anweisung.
STEP_ID	NUMBER(38, 0)	Bezeichner des Schritts im Abfrageplan.
OPERATOR_ID	NUMBER(38, 0)	Bezeichner des Operators. Dieser ist innerhalb der Abfrage eindeutig. Die Werte beginnen bei 0.
PARENT_OPERATORS	ARRAY mit einem oder mehreren NUMBER(38, 0)-Werten	Die Bezeichner der übergeordneten Operatoren dieses Operators oder NULL, wenn es sich um den letzten Operator im Abfrageplan handelt (in der Regel der „Result“-Operator).
OPERATOR_TYPE	VARCHAR	The type of query operator; for example, `TableScan` or `Filter`.
OPERATOR_STATISTICS	VARIANT, enthält ein OBJECT	Statistics about the operator (for example, the number of output rows from the operator).
EXECUTION_TIME_BREAKDOWN	VARIANT, enthält ein OBJECT	Informationen zur Ausführungszeit des Operators.
OPERATOR_ATTRIBUTES	VARIANT, enthält ein OBJECT	Information about the operator. This information depends on the operator type.

Wenn es keine Informationen zu dieser spezifischen Spalte zu dem Operator gibt, ist der Wert NULL.

Three of these columns contain OBJECTs. Each object contains key/value pairs. The tables below describe the keys in these objects.

OPERATOR_STATISTICS¶

Die Felder in den OBJECTs für die Spalte OPERATOR_STATISTICS enthalten zusätzliche Informationen zu dem Operator. Dazu zählen folgende Informationen:

Schlüssel	Nested key (if applicable)	Data type	Beschreibung
`dml`			Statistics for Data Manipulation Language (DML) queries.
	`number_of_rows_inserted`	DOUBLE	Number of rows inserted into a table or tables.
	`number_of_rows_updated`	DOUBLE	Number of rows updated in a table.
	`number_of_rows_deleted`	DOUBLE	Number of rows deleted from a table.
	`number_of_rows_unloaded`	DOUBLE	Number of rows unloaded during data export.
`extension_functions`			Information about calls to extension functions. If the value of a field is zero, then the field is not displayed.
	`Java UDF handler load time`	DOUBLE	Amount of time for the Java UDF handler to load.
	`Total Java UDF handler invocations`	DOUBLE	Number of times the Java UDF handler is invoked.
	`Max Java UDF handler execution time`	DOUBLE	Maximum amount of time for the Java UDF handler to execute.
	`Avg Java UDF handler execution time`	DOUBLE	Average amount of time to execute the Java UDF handler.
	`Java UDTF process() invocations`	DOUBLE	Number of times the Java UDTF process method was invoked.
	`Java UDTF process() execution time`	DOUBLE	Amount of time to execute the Java UDTF process.
	`Avg Java UDTF process() execution time`	DOUBLE	Average amount of time to execute the Java UDTF process.
	`Java UDTF's constructor invocations`	DOUBLE	Number of times the Java UDTF constructor was invoked.
	`Java UDTF's constructor execution time`	DOUBLE	Amount of time to execute the Java UDTF constructor.
	`Avg Java UDTF's constructor execution time`	DOUBLE	Average amount of time to execute the Java UDTF constructor.
	`Java UDTF endPartition() invocations`	DOUBLE	Number of times the Java UDTF endPartition method was invoked.
	`Java UDTF endPartition() execution time`	DOUBLE	Amount of time to execute the Java UDTF endPartition method.
	`Avg Java UDTF endPartition() execution time`	DOUBLE	Average amount of time to execute the Java UDTF `endPartition` method.
	`Max Java UDF dependency download time`	DOUBLE	Maximum amount of time to download the Java UDF dependencies.
	`Max JVM memory usage`	DOUBLE	Peak memory usage as reported by the JVM.
	`Java UDF inline code compile time in ms`	DOUBLE	Compile time for the Java UDF inline code.
	`Total Python UDF handler invocations`	DOUBLE	Number of times the Python UDF handler was invoked.
	`Total Python UDF handler execution time`	DOUBLE	Total execution time for the Python UDF handler.
	`Avg Python UDF handler execution time`	DOUBLE	Average amount of time to execute the Python UDF handler.
	`Python sandbox max memory usage`	DOUBLE	Peak memory usage by the Python sandbox environment.
	`Avg Python env creation time: Download and install packages`	DOUBLE	Average amount of time to create the Python environment, including downloading and installing packages.
	`Conda solver time`	DOUBLE	Amount of time to run the Conda solver to solve Python packages.
	`Conda env creation time`	DOUBLE	Amount of time to create the Python environment.
	`Python UDF initialization time`	DOUBLE	Amount of time to initialize the Python UDF.
	`Number of external file bytes read for UDFs`	DOUBLE	Number of external file bytes read for UDFs.
	`Number of external files accessed for UDFs`	DOUBLE	Number of external files accessed for UDFs.
`external_functions`			Information about calls to external functions. If the value of a field — for example `retries_due_to_transient_errors` — is zero, then the field is not displayed.
	`total_invocations`	DOUBLE	Number of times that an external function was called. This number can be different from the number of external function calls in the text of the SQL statement because of the number of batches that rows are divided into, the number of retries if there are transient network problems, and so on.
	`rows_sent`	DOUBLE	Number of rows sent to external functions.
	`rows_received`	DOUBLE	Number of rows received back from external functions.
	`bytes_sent (x-region)`	DOUBLE	Number of bytes sent to external functions. If the key includes `(x-region)`, the data was sent across regions, which can impact billing.
	`bytes_received (x-region)`	DOUBLE	Number of bytes received from external functions. If the key includes `(x-region)`, the data was sent across regions, which can impact billing.
	`retries_due_to_transient_errors`	DOUBLE	Number of retries because of transient errors.
	`average_latency_per_call`	DOUBLE	Average amount of time per invocation (call) in milliseconds between the time Snowflake sent the data and received the returned data.
	`http_4xx_errors`	INTEGER	Gesamtzahl der HTTP-Anforderungen, die einen 4xx-Statuscode zurückgegeben haben.
	`http_5xx_errors`	INTEGER	Gesamtzahl der HTTP-Anforderungen, die einen 5xx-Statuscode zurückgegeben haben.
	`average_latency`	DOUBLE	Durchschnittliche Latenz für erfolgreiche HTTP-Anforderungen.
	`avg_throttle_latency_overhead`	DOUBLE	Average overhead per successful request because of a slowdown caused by throttling (HTTP 429).
	`batches_retried_due_to_throttling`	DOUBLE	Number of batches that were retried because of HTTP 429 errors.
	`latency_per_successful_call_(p50)`	DOUBLE	50th percentile latency for successful HTTP requests. 50 percent of all successful requests took less than this time to complete.
	`latency_per_successful_call_(p90)`	DOUBLE	90th percentile latency for successful HTTP requests. 90 percent of all successful requests took less than this time to complete.
	`latency_per_successful_call_(p95)`	DOUBLE	95th percentile latency for successful HTTP requests. 95 percent of all successful requests took less than this time to complete.
	`latency_per_successful_call_(p99)`	DOUBLE	99th percentile latency for successful HTTP requests. 99 percent of all successful requests took less than this time to complete.
`input_rows`		INTEGER	Number of input rows. This can be missing for an operator with no input edges from other operators.
`io`			Informationen zu den während der Abfrage ausgeführten Eingabe/Ausgabe-Operationen.
	`scan_progress`	DOUBLE	Percentage of data scanned for a given table so far.
	`bytes_scanned`	DOUBLE	Number of bytes scanned so far.
	`percentage_scanned_from_cache`	DOUBLE	Percentage of data scanned from the local disk cache.
	`bytes_written`	DOUBLE	Bytes written; for example, when loading into a table.
	`bytes_written_to_result`	DOUBLE	Anzahl der Bytes, die in ein Ergebnisobjekt geschrieben wurden. For example, `SELECT * FROM ...` would produce a set of results in tabular format representing each field in the selection. Im Allgemeinen repräsentiert das Ergebnisobjekt das, was als Ergebnis der Abfrage erzeugt wird, und `bytes_written_to_result` steht für die Größe des zurückgegebenen Ergebnisses.
	`bytes_read_from_result`	DOUBLE	Anzahl der Bytes, die aus einem Ergebnisobjekt gelesen wurden.
	`external_bytes_scanned`	DOUBLE	Bytes read from an external object; for example, a stage.
`network`	`network_bytes`	DOUBLE	Amount of data sent over the network.
`output_rows`		INTEGER	Number of output rows. This can be missing for the operator that returns the results to the user; which is usually the RESULT operator.
`pruning`			Informationen zu den Auswirkungen der Tabellenverkürzung:
	`partitions_pruned_by_snowflake_optima`	DOUBLE	Number of partitions pruned by Snowflake Optima.
	`partitions_scanned`	DOUBLE	Number of partitions scanned so far.
	`partitions_total`	DOUBLE	Total number of partitions in a given table.
`spilling`			Informationen zur Festplattennutzung für Operationen, bei denen Zwischenergebnisse nicht in den Arbeitsspeicher passen.
	`bytes_spilled_remote_storage`	DOUBLE	Volume of data spilled to remote disk.
	`bytes_spilled_local_storage`	DOUBLE	Volume of data spilled to local disk.
`search_optimization`			Informationen zu Abfragen, die den Suchoptimierungsservice nutzen.
	`partitions_pruned_by_search_optimization`	DOUBLE	Number of partitions pruned by search optimization.
	`partitions_pruned_by_search_optimization_and_snowflake_optima`	DOUBLE	Anzahl der Partitionen, die durch die Suchoptimierung und Snowflake Optima bereinigt wurden.

EXECUTION_TIME_BREAKDOWN¶

Die Felder in den OBJECTs für die Spalte EXECUTION_TIME_BREAKDOWN sind unten aufgeführt.

Schlüssel	Data type	Beschreibung
`overall_percentage`	DOUBLE	Percentage of the total query time spent by this operator.
`initialization`	DOUBLE	Zeit, die für das Einrichten der Abfrageverarbeitung verbraucht wurde.
`processing`	DOUBLE	Zeit, die für die Verarbeitung der Daten durch die CPU verbraucht wurde.
`synchronization`	DOUBLE	Zeit, die für das Synchronisieren der Aktivitäten zwischen den beteiligten Prozessen verbraucht wurde.
`local_disk_io`	DOUBLE	Zeit, in der die Verarbeitung blockiert war, weil auf den Zugriff auf die lokale Festplatte gewartet wurde.
`remote_disk_io`	DOUBLE	Zeit, in der die Verarbeitung blockiert war, weil auf den Remote-Festplattenzugriff gewartet wurde.
`network_communication`	DOUBLE	Zeit, in der die Verarbeitung auf den Netzwerk-Datentransfer gewartet hat.

OPERATOR_ATTRIBUTES¶

Each output row describes one operator in the query. The following table shows the possible types of operators; for example, the Filter operator. For each type of operator, the table shows the possible attributes; for example, the expression used to filter the rows.

Die Operatorattribute werden in der Spalte OPERATOR_ATTRIBUTES gespeichert, die vom Typ VARIANT ist und ein OBJECT enthält. Das OBJECT enthält Schlüssel/Wert-Paare. Jeder Schlüssel entspricht einem Attribut des Operators.

Operator name	Schlüssel	Data type	Beschreibung
`Aggregate`
	`functions`	ARRAY von VARCHAR	Liste der berechneten Funktionen.
	`grouping_keys`	ARRAY von VARCHAR	Group-by expression.
`CartesianJoin`
	`additional_join_condition`	VARCHAR	Join-Ausdruck, der auf Ungleichheit basiert
	`equality_join_condition`	VARCHAR	Join-Ausdruck, der auf Gleichheit basiert
	`join_type`	VARCHAR	Join-Typ (INNER)
`Delete`	`table_name`	VARCHAR	Name der aktualisierten Tabelle.
`ExternalScan`
	`stage_name`	VARCHAR	Name des Stagingbereichs, aus dem die Daten gelesen werden.
	`stage_type`	VARCHAR	Typ des Stagingbereichs.
`Filter`	`filter_condition`	VARCHAR	Der zum Filtern der Daten verwendete Ausdruck.
`Flatten`	`input`	VARCHAR	Input expression used to flatten data.
`Generator`
	`row_count`	NUMBER	Wert des Eingabeparameters ROWCOUNT.
	`time_limit`	NUMBER	Wert des Eingabeparameters TIMELIMIT.
`GroupingSets`
	`functions`	ARRAY von VARCHAR	Liste der berechneten Funktionen.
	`key_sets`	ARRAY von VARCHAR	Liste der Gruppierungssätze.
`Insert`
	`input_expression`	VARCHAR	Ausdrücke, die eingefügt werden.
	`table_names`	ARRAY von VARCHAR	Liste der Tabellennamen, denen Datensätze hinzugefügt werden.
`InternalObject`	`object_name`	VARCHAR	Name of the accessed object.
`Join`
	`additional_join_condition`	VARCHAR	Join-Ausdruck, der auf Ungleichheit basiert
	`equality_join_condition`	VARCHAR	Join-Ausdruck, der auf Gleichheit basiert
	`join_type`	VARCHAR	Join-Typ (INNER, OUTER, LEFT JOIN usw.).
`JoinFilter`	`join_id`	NUMBER	Operator id of the join used to identify tuples that can be filtered out.
`Merge`	`table_name`	VARCHAR	Name der aktualisierten Tabelle.
`Pivot`
	`grouping_keys`	ARRAY von VARCHAR	Verbleibende Spalten, über die die Ergebnisse aggregiert werden.
	`pivot_column`	ARRAY von VARCHAR	Resultierende Spalten der Pivot-Werte.
`Result`	`expressions`	ARRAY von VARCHAR	Liste der Ausdrücke, die generiert wurden.
`Sort`	`sort_keys`	ARRAY von VARCHAR	Ausdruck, der die Sortierreihenfolge definiert.
`SortWithLimit`
	`offset`	NUMBER	Position in der sortierten Sequenz, ab der die produzierten Tupel ausgegeben werden.
	`rows`	NUMBER	Anzahl der erzeugten Zeilen.
	`sort_keys`	ARRAY von VARCHAR	Ausdruck, der die Sortierreihenfolge definiert.
`TableScan`
	`columns`	ARRAY von VARCHAR	Liste der gescannten Spalten.
	`extracted_variant_paths`	ARRAY von VARCHAR	Liste der aus den Variantenspalten extrahierten Pfade.
	`table_alias`	VARCHAR	Alias der Tabelle, auf die zugegriffen wurde.
	`table_name`	VARCHAR	Name der Tabelle, auf die zugegriffen wurde.
`Unload`	`location`	VARCHAR	Stagingbereich, in dem die Daten gespeichert werden.
`Unpivot`	`expressions`	ARRAY von VARCHAR	Ausgabespalten der Unpivot-Abfrage.
`Update`	`table_name`	VARCHAR	Name der aktualisierten Tabelle.
`ValuesClause`
	`value_count`	NUMBER	Anzahl der produzierten Werte.
	`values`	VARCHAR	Liste der Werte.
`WindowFunction`	`functions`	ARRAY von VARCHAR	Liste der berechneten Funktionen.
`WithClause`	`name`	VARCHAR	Alias der WITH-Klausel.

Wenn ein Operator nicht aufgeführt ist, werden keine Attribute erzeugt, und der Wert wird als {} berichtet.

Bemerkung

The following operators do not have any operator attributes and therefore are not included in the table of OPERATOR_ATTRIBUTES:
- UnionAll
- ExternalFunction

Beispiele¶

Die folgenden Beispiele rufen die Funktion GET_QUERY_OPERATOR_STATS auf.

Abrufen von Daten zu einer einzelnen Abfrage¶

Dieses Beispiel zeigt die Statistiken für ein SELECT, das zwei kleine Tabellen miteinander verknüpft.

Führen Sie die SELECT-Anweisung aus:

SELECT x1.i, x2.i
  FROM x1 INNER JOIN x2 ON x2.i = x1.i
  ORDER BY x1.i, x2.i;

Copy

Rufen Sie die Abfrage-ID ab:

SET lqid = (SELECT LAST_QUERY_ID());

Copy

Rufen Sie GET_QUERY_OPERATOR_STATS() auf, um Statistiken zu den einzelnen Operatoren der Abfrage zu erhalten:

SELECT * FROM TABLE(GET_QUERY_OPERATOR_STATS($lqid));

Copy

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

Identifizieren von „explodierenden“ Join-Operatoren¶

Das folgende Beispiel zeigt, wie mit GET_QUERY_OPERATOR_STATS eine komplizierte Abfrage untersucht werden kann. In diesem Beispiel wird nach Operatoren innerhalb einer Abfrage gesucht, die viel mehr Zeilen erzeugen, als für diesen Operator eingegeben wurden.

Folgende Abfrage wird analysiert:

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

Rufen Sie die Abfrage-ID der Abfrage ab:

SET lid = LAST_QUERY_ID();

Copy

The following query shows the ratio of output rows to input rows for each of the join operators in the query:

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;

Copy

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

Nachdem Sie die explodierenden Joins identifiziert haben, können Sie jede Join-Bedingung überprüfen, um sicherzustellen, dass die Bedingung korrekt ist.