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.

Sie können diese Informationen verwenden, um die Struktur einer Abfrage zu verstehen und Abfrageoperatoren (z. B. den Verknüpfungsoperator) zu identifizieren, die Performanceprobleme verursachen.

Anhand dieser Informationen können Sie zum Beispiel feststellen, welche Operatoren die meisten Ressourcen verbrauchen. Als weiteres Beispiel können Sie diese Funktion verwenden, um Verknüpfungen (Joins) zu identifizieren, die mehr Ausgabe- als Eingabezeilen haben, was ein Zeichen für einen „explodierenden“ Join sein kann (z. B. ein unbeabsichtigtes kartesisches Produkt).

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¶

Diese Funktion gibt nur Statistiken zu abgeschlossene Abfragen zurück.
Sie müssen über die Berechtigungen OPERATE oder MONITOR für das Warehouse verfügen, in dem Sie die Abfrage ausgeführt haben.
Diese Funktion liefert detaillierte Statistiken zu jedem Abfrageoperator, der in der angegebenen Abfrage verwendet wird. Zu den möglichen Abfrageoperatoren gehören:
- Aggregate: Gruppiert die Eingabe und berechnet Aggregationsfunktionen.
- 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: Generiert Datensätze mit dem TABLE(GENERATOR(…))-Konstrukt.
- GroupingSets: Repräsentiert Konstrukte wie GROUPING SETS, ROLLUP und CUBE.
- Insert: Fügt einen Datensatz entweder durch eine INSERT- oder eine COPY-Operation zu einer Tabelle hinzu.
- InternalObject: Repräsentiert den Zugriff auf ein internes Datenobjekt (z. B. in einem Information Schema oder das Ergebnis einer vorherigen Abfrage).
- 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).

Statistiken, die die Ausführungszeit von Abfragen aufschlüsseln, werden als Prozentsatz der Zeit ausgedrückt, die für die gesamte Abfrage benötigt wurde.

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:

Spaltenname	Datentyp	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	Typ des Abfrageoperators (z. B. `TableScan` oder `Filter`).
OPERATOR_STATISTICS	VARIANT, enthält ein OBJECT	Statistiken zum Operator (z. B. Anzahl der Ausgabezeilen von diesem Operator).
EXECUTION_TIME_BREAKDOWN	VARIANT, enthält ein OBJECT	Informationen zur Ausführungszeit des Operators.
OPERATOR_ATTRIBUTES	VARIANT, enthält ein OBJECT	Informationen zum Operator. Diese Informationen hängen vom Typ des Operators ab.

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

Drei dieser Spalten enthalten OBJECTs. Jedes Objekt enthält Schlüssel/Wert-Paare. Die folgenden Tabellen enthalten Informationen zu den Schlüsseln in diesen Tabellen.

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	Verschachtelter Schlüssel (falls zutreffend)	Datentyp	Beschreibung
`dml`			Statistiken zu DML-Abfragen (Datenbearbeitungssprache):
	`number_of_rows_inserted`	DOUBLE	Anzahl der in eine Tabelle (oder Tabellen) eingefügten Zeilen.
	`number_of_rows_updated`	DOUBLE	Anzahl der in einer Tabelle aktualisierten Zeilen.
	`number_of_rows_deleted`	DOUBLE	Anzahl der aus einer Tabelle gelöschten Zeilen.
	`number_of_rows_unloaded`	DOUBLE	Anzahl der während des Datenexports entladenen Zeilen.
`external_functions`			Informationen zu Aufrufen externer Funktionen. Wenn der Wert eines Feldes, z. B. `retries_due_to_transient_errors`, null ist, wird das Feld nicht angezeigt.
	`total_invocations`	DOUBLE	Häufigkeit, mit der eine externe Funktion aufgerufen wurde. Der Wert kann sich von der Anzahl der externen Funktionsaufrufe im Text der SQL-Anweisung unterscheiden und zwar aufgrund der Anzahl der Batches, in die Zeilen unterteilt sind, der Anzahl der Wiederholungsversuche (bei vorübergehenden Netzwerkproblemen) usw.
	`rows_sent`	DOUBLE	Anzahl der an externe Funktionen gesendeten Zeilen.
	`rows_received`	DOUBLE	Anzahl der von externen Funktionen empfangenen Zeilen.
	`bytes_sent (x-region)`	DOUBLE	Anzahl der an externe Funktionen gesendeten Bytes. Wenn der Schlüssel `(x-region)` enthält, wurden die Daten über Regionen hinweg gesendet (was sich auf die Abrechnung auswirken kann).
	`bytes_received (x-region)`	DOUBLE	Anzahl der von externen Funktionen empfangenen Bytes. Wenn der Schlüssel `(x-region)` enthält, wurden die Daten über Regionen hinweg gesendet (was sich auf die Abrechnung auswirken kann).
	`retries_due_to_transient_errors`	DOUBLE	Anzahl der Wiederholungen aufgrund transienter Fehler.
	`average_latency_per_call`	DOUBLE	Durchschnittliche Zeit pro Aufruf zwischen dem Zeitpunkt, zu dem Snowflake die Daten gesendet hat, und dem Zeitpunkt, zu dem Snowflake die zurückgegebenen Daten empfangen hat.
	`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	Durchschnittlicher Overhead pro erfolgreicher Anforderung aufgrund einer durch Drosselung verursachten Verlangsamung (HTTP 429).
	`batches_retried_due_to_throttling`	DOUBLE	Anzahl der Batches, deren Ausführung aufgrund von HTTP-Fehler 429 erneut versucht wurden.
	`latency_per_successful_call_(p50)`	DOUBLE	50. Perzentil der Latenz für erfolgreiche HTTP-Anforderungen. 50 Prozent aller erfolgreichen Anforderungen wurden in weniger als dieser Zeit abgeschlossen.
	`latency_per_successful_call_(p90)`	DOUBLE	90. Perzentil der Latenz für erfolgreiche HTTP-Anforderungen. 90 Prozent aller erfolgreichen Anforderungen wurden in weniger als dieser Zeit abgeschlossen.
	`latency_per_successful_call_(p95)`	DOUBLE	95. Perzentil der Latenz für erfolgreiche HTTP-Anforderungen. 95 Prozent aller erfolgreichen Anforderungen wurden in weniger als dieser Zeit abgeschlossen.
	`latency_per_successful_call_(p99)`	DOUBLE	99. Perzentil der Latenz für erfolgreiche HTTP-Anforderungen. 99 Prozent aller erfolgreichen Anforderungen wurden in weniger als dieser Zeit abgeschlossen.
`input_rows`		INTEGER	Anzahl der Eingabezeilen. Dies kann bei einem Operator fehlen, der keine Eingaben von anderen Operatoren erhält.
`io`			Informationen zu den während der Abfrage ausgeführten Eingabe/Ausgabe-Operationen.
	`scan_progress`	DOUBLE	Prozentsatz der Daten, die bislang für eine bestimmte Tabelle gescannt wurden.
	`bytes_scanned`	DOUBLE	Anzahl der bislang gescannten Bytes.
	`percentage_scanned_from_cache`	DOUBLE	Prozentsatz der Daten, die vom lokalen Festplattencache gescannt wurden.
	`bytes_written`	DOUBLE	Anzahl geschriebener Bytes (z. B. beim Laden in eine Tabelle).
	`bytes_written_to_result`	DOUBLE	Anzahl der Bytes, die in ein Ergebnisobjekt geschrieben wurden. So würde beispielsweise `select * from . . .` eine Menge von Ergebnissen im tabellarischen Format für jedes Feld in der Auswahl liefern. 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, die von einem externen Objekt (z. B. einem Stagingbereich) gelesen wurden.
`network`	`network_bytes`	DOUBLE	Datenmenge, die über das Netzwerk gesendete wurde.
`output_rows`		INTEGER	Anzahl der Ausgabezeilen. Dies kann bei dem Operator fehlen, der die Ergebnisse an den Benutzer zurückgibt (in der Regel ist dies der RESULT-Operator).
`pruning`			Informationen zu den Auswirkungen der Tabellenverkürzung:
	`partitions_scanned`	DOUBLE	Anzahl der bisher gescannten Partitionen.
	`partitions_total`:	DOUBLE	Gesamtanzahl der Partitionen einer Tabelle.
`spilling`			Informationen zur Festplattennutzung für Operationen, bei denen Zwischenergebnisse nicht in den Arbeitsspeicher passen.
	`bytes_spilled_remote_storage`	DOUBLE	Datenmenge, die auf eine externe Festplatte übertragen wurde.
	`bytes_spilled_local_storage`	DOUBLE	Datenmenge, die auf eine lokale Festplatte übertragen wurde.
`extension_functions`			Informationen zu Aufrufen von Erweiterungsfunktionen. Wenn der Wert eines Feldes null ist, wird das Feld nicht angezeigt.
	`Java UDF handler load time`	DOUBLE	Zeitaufwand für das Laden des Java-UDF-Handlers.
	`Total Java UDF handler invocations`	DOUBLE	Anzahl der Aufrufe des Java-UDF-Handlers.
	`Max Java UDF handler execution time`	DOUBLE	Maximaler Zeitaufwand für die Ausführung des Java-UDF-Handlers.
	`Avg Java UDF handler execution time`	DOUBLE	Durchschnittlicher Zeitaufwand für die Ausführung des Java-UDF-Handlers.
	`Java UDTF process() invocations`	DOUBLE	Anzahl der Aufrufe der Java-UDTF-Prozessmethode.
	`Java UDTF process() execution time`	DOUBLE	Zeitaufwand für die Ausführung des Java-UDTF-Prozesses.
	`Avg Java UDTF process() execution time`	DOUBLE	Durchschnittlicher Zeitaufwand für die Ausführung des Java-UDTF-Prozesses.
	`Java UDTF's constructor invocations`	DOUBLE	Anzahl der Aufrufe des Java-UDTF-Konstruktors.
	`Java UDTF's constructor execution time`	DOUBLE	Zeitaufwand für die Ausführung des Java-UDTF-Konstruktors.
	`Avg Java UDTF's constructor execution time`	DOUBLE	Durchschnittlicher Zeitaufwand für die Ausführung des Java-UDTF-Konstruktors.
	`Java UDTF endPartition() invocations`	DOUBLE	Anzahl der Aufrufe der Java-UDTF-endPartition-Methode.
	`Java UDTF endPartition() execution time`	DOUBLE	Zeitaufwand für die Ausführung der Java-UDTF-endPartition-Methode.
	`Avg Java UDTF endPartition() execution time`	DOUBLE	Durchschnittlicher Zeitaufwand für die Ausführung der Java-UDTF-endPartition-Methode.
	`Max Java UDF dependency download time`	DOUBLE	Maximaler Zeitaufwand für das Herunterladen der Java-UDF-Abhängigkeiten.
	`Max JVM memory usage`	DOUBLE	Spitzenauslastung des Arbeitsspeichers, wie von der JVM gemeldet.
	`Java UDF inline code compile time in ms`	DOUBLE	Kompilierungszeit für den Java-UDF-Inline-Code.
	`Total Python UDF handler invocations`	DOUBLE	Anzahl der Aufrufe des Python-UDF-Handlers.
	`Total Python UDF handler execution time`	DOUBLE	Gesamtausführungszeit für den Python-UDF-Handler.
	`Avg Python UDF handler execution time`	DOUBLE	Durchschnittlicher Zeitaufwand für die Ausführung des Python-UDF-Handlers.
	`Python sandbox max memory usage`	DOUBLE	Spitzenauslastung des Arbeitsspeichers durch die Python-Sandbox-Umgebung.
	`Avg Python env creation time: Download and install packages`	DOUBLE	Durchschnittlicher Zeitaufwand für das Erstellen der Python-Umgebung, einschließlich des Herunterladens und Installierens von Paketen.
	`Conda solver time`	DOUBLE	Zeitaufwand für die Ausführung des Conda-Solvers zur Auflösung von Python-Paketen.
	`Conda env creation time`	DOUBLE	Zeitaufwand für das Erstellen der Python-Umgebung.
	`Python UDF initialization time`	DOUBLE	Zeitaufwand für das Initialisieren der Python-UDF.
	`Number of external file bytes read for UDFs`	DOUBLE	Anzahl der für UDFs gelesenen Bytes für externe Dateien.
	`Number of external files accessed for UDFs`	DOUBLE	Anzahl der externen Dateien, auf die für UDFszugegriffen wurde.

EXECUTION_TIME_BREAKDOWN¶

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

Schlüssel	Datentyp	Beschreibung
`overall_percentage`	DOUBLE	Prozentsatz der gesamten Abfragezeit, der auf diesen Operator entfällt.
`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¶

Jede Ausgabezeile beschreibt genau einen Operator der Abfrage. Die folgende Tabelle zeigt die möglichen Typen von Operatoren (z. B. den „Filter“-Operator). Für jeden Typ von Operator zeigt die Tabelle die möglichen Attribute an (z. B. den Ausdruck, der zum Filtern der Zeilen verwendet wird).

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.

Name des Operators	Schlüssel	Datentyp	Beschreibung
`Aggregate`
	`functions`	ARRAY von VARCHAR	Liste der berechneten Funktionen.
	`grouping_keys`	ARRAY von VARCHAR	Der Gruppierungsausdruck.
`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	Eingabeausdruck, der zum Vereinfachen der Daten verwendet wird.
`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 des Objekts, auf das zugegriffen wurde.
`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 des Join, mit dem Tupel identifiziert werden, die herausgefiltert werden können.
`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

Die folgenden Operatoren haben keine Operatorattribute und sind daher nicht in der Tabelle von OPERATOR_ATTRIBUTES enthalten:
- UnionAll
- ExternalFunction

Beispiele¶

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

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

Die folgende Abfrage zeigt das Verhältnis von Ausgabezeilen zu Eingabezeilen für jeden Join-Operator der Abfrage an.

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

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