Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Funktionen für Tabellenkalkulationen
Wenn Sie Daten für bestimmte visualisierte Daten analysieren, können Sie Tabellenberechnungen auf den aktuellen Datensatz anwenden, um herauszufinden, wie Dimensionen die Messwerte oder einander beeinflussen. *Visualisierte Daten* sind Ihre Ergebnismenge basierend auf Ihrem aktuellen Datensatz, wobei alle Filter, Feldauswahlen und Anpassungen angewendet werden. Um genau zu sehen, wie diese Ergebnismenge aussieht können Sie Ihre visualisierten Daten in eine Datei exportieren. Eine *Tabellenberechnungsfunktion* führt Operationen mit den Daten durch, um Beziehungen zwischen Feldern aufzudecken.
In diesem Abschnitt finden Sie eine Liste der Funktionen, die in Tabellenberechnungen verfügbar sind und die Sie mit visualisierten Daten in Amazon Quick ausführen können.
Eine nach Kategorien sortierte Liste der Funktionen mit kurzen Definitionen finden Sie unter [Funktionen nach Kategorien](https://docs.aws.amazon.com/quicksight/latest/user/functions-by-category.html).
**Topics**
+ [difference](difference-function.md)
+ [distinctCountOver](distinctCountOver-function.md)
+ [lag](lag-function.md)
+ [lead](lead-function.md)
+ [percentDifference](percentDifference-function.md)
+ [avgOver](avgOver-function.md)
+ [countOver](countOver-function.md)
+ [maxOver](maxOver-function.md)
+ [minOver](minOver-function.md)
+ [percentileOver](percentileOver-function.md)
+ [percentileContOver](percentileContOver-function.md)
+ [percentileDiscOver](percentileDiscOver-function.md)
+ [percentOfTotal](percentOfTotal-function.md)
+ [periodOverPeriodDifference](periodOverPeriodDifference-function.md)
+ [periodOverPeriodLastValue](periodOverPeriodLastValue-function.md)
+ [periodOverPeriodPercentDifference](periodOverPeriodPercentDifference-function.md)
+ [periodToDateAvgOverTime](periodToDateAvgOverTime-function.md)
+ [periodToDateCountOverTime](periodToDateCountOverTime-function.md)
+ [periodToDateMaxOverTime](periodToDateMaxOverTime-function.md)
+ [periodToDateMinOverTime](periodToDateMinOverTime-function.md)
+ [periodToDateSumOverTime](periodToDateSumOverTime-function.md)
+ [stdevOver](stdevOver-function.md)
+ [stdevpOver](stdevpOver-function.md)
+ [varOver](varOver-function.md)
+ [varpOver](varpOver-function.md)
+ [sumOver](sumOver-function.md)
+ [denseRank](denseRank-function.md)
+ [rank](rank-function.md)
+ [percentileRank](percentileRank-function.md)
+ [runningAvg](runningAvg-function.md)
+ [runningCount](runningCount-function.md)
+ [runningMax](runningMax-function.md)
+ [runningMin](runningMin-function.md)
+ [runningSum](runningSum-function.md)
+ [firstValue](firstValue-function.md)
+ [lastValue](lastValue-function.md)
+ [windowAvg](windowAvg-function.md)
+ [windowCount](windowCount-function.md)
+ [windowMax](windowMax-function.md)
+ [windowMin](windowMin-function.md)
+ [windowSum](windowSum-function.md)
# difference
Die Funktion `difference` berechnet die Differenz zwischen einem Messwert, der auf einem Satz von Partitionen basiert und sortiert, und einem Messwert, der auf einem anderen basiert.
Die Funktion `difference` wird für Analysen auf Basis von SPICE und direkten Abfragedatensätzen unterstützt.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
difference
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index,
,[ partition field, ... ]
)
```
## Argumente
*measure*
Eine aggregierte Kennzahl, für die Sie die Differenz sehen möchten.
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*lookup index*
Der Lookup-Index kann positiv (nachfolgende Zeile in der Sortierung) oder negativ (vorherige Zeile in der Sortierung) sein. Der Lookup-Index kann 1–2 147 483 647 sein. Für die Engines MySQL, MariaDB und die MySQL-kompatible Aurora-Edition ist der Lookup-Index auf 1 beschränkt.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet die Differenz zwischen `sum({Billed Amount})`, sortiert nach `Customer Region`, aufsteigend zur nächsten Zeile und partitioniert nach `Service Line`.
```
difference(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1,
[{Service Line}]
)
```
Das folgende Beispiel berechnet die Differenz zwischen `Billed Amount` und der nächsten Zeile, partitioniert nach (`[{Customer Region}]`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
difference(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1
)
```
Die roten Markierungen zeigen, wie jeder Betrag addiert wird (a \$1 b = c), um die Differenz zwischen den Beträgen a und c anzuzeigen.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/differenceCalc.png)
# distinctCountOver
Die `distinctCountOver`-Funktion berechnet die eindeutige Anzahl der Operanden, partitioniert nach den angegebenen Attributen auf einer bestimmten Ebene. Unterstützte Stufen sind `PRE_FILTER` und `PRE_AGG`. Der Operand muss nicht aggregiert sein.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
distinctCountOver
(
measure or dimension field
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure or dimension field (Metrik- oder Dimensionsfeld)*
Die Metrik oder die Dimension, für die Sie die Berechnung durchführen möchten, z. B. `{Sales Amt}`. Gültige Werte sind `PRE_FILTER` und `PRE_AGG`.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
Dieser Wert ist standardmäßig `POST_AGG_FILTER`, wenn er leer ist. `POST_AGG_FILTER` ist keine gültige Ebene für diesen Vorgang und führt zu einer Fehlermeldung. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Amazon](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html) Quick.
## Beispiel
Das folgende Beispiel liefert die Anzahl der eindeutigen Daten von `Sales`, die über `City` und `State` auf der Ebene `PRE_AGG` partitioniert sind.
```
distinctCountOver
(
Sales,
[City, State], PRE_AGG
)
```
# lag
Die Funktion `lag` berechnet den Lag-Wert (Verzögerung) für einen Messwert basierend auf bestimmten Partitionen und Sortierungen.
`lag` wird für Analysen auf Basis von SPICE und direkten Abfragedatensätzen unterstützt.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
lag
(
lag
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index
,[ partition_field, ... ]
)]
)
```
## Argumente
*measure*
Der Messwert, für den Sie die Verzögerung abrufen wollen. Dies kann ein Aggregat sein (z. B. `sum({Sales Amt})`).
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*lookup index*
Der Lookup-Index kann positiv (nachfolgende Zeile in der Sortierung) oder negativ (vorherige Zeile in der Sortierung) sein. Der Lookup-Index kann 1–2 147 483 647 sein. Für die Engines MySQL, MariaDB und die MySQL-kompatible Amazon-Aurora-Edition ist der Lookup-Index auf 1 beschränkt.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet das vorherige `sum(sales)`, partitioniert nach dem Ursprungsland, in aufsteigender Reihenfolge nach `cancellation_code`.
```
lag
(
sum(Sales),
[cancellation_code ASC],
1,
[origin_state_nm]
)
```
Das folgende Beispiel verwendet ein berechnetes Feld mit `lag`, um den Verkaufsbetrag für die vorherige Zeile neben dem Betrag für die aktuelle Zeile anzuzeigen (sortiert nach `Order Date`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
lag(
sum({Sales}),
[{Order Date} ASC],
1
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/lagCalc.png)
Das folgende Beispiel verwendet ein berechnetes Feld mit `lag`, um den Verkaufsbetrag für die vorherige Zeile neben dem Betrag für die aktuelle Zeile anzuzeigen, sortiert nach `Order Date`, aufgeteilt nach `Segment`.
```
lag
(
sum(Sales),
[Order Date ASC],
1, [Segment]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/lagCalc2.png)
# lead
Die Funktion `lead` berechnet den Lead-Wert (Vorlauf) für einen Messwert basierend auf bestimmten Partitionen und Sortierungen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
lead
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index,
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Der Messwert, für den Sie den Vorlauf abrufen wollen. Dies kann ein Aggregat sein (z. B. `sum({Sales Amt})`).
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*lookup index*
Der Lookup-Index kann positiv (nachfolgende Zeile in der Sortierung) oder negativ (vorherige Zeile in der Sortierung) sein. Der Lookup-Index kann 1–2 147 483 647 sein. Für die Engines MySQL, MariaDB und die MySQL-kompatible Amazon-Aurora-Edition ist der Lookup-Index auf 1 beschränkt.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet das nächste `sum(sales)`, partitioniert nach dem Ursprungsland, in aufsteigender Reihenfolge nach `cancellation_code`.
```
lead
(
sum(sales),
[cancellation_code ASC],
1,
[origin_state_nm]
)
```
Das folgende Beispiel verwendet ein berechnetes Feld mit Lead, um den Betrag für die nächste Zeile neben dem Betrag für die aktuelle Zeile anzuzeigen (sortiert nach `Customer Segment`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
lead(
sum({Billed Amount}),
[{Customer Segment} ASC],
1
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/leadCalc.png)
# percentDifference
Die Funktion `percentDifference` berechnet die prozentuale Differenz zwischen dem aktuellen Wert und einem Vergleichswert, basierend auf Partitionen, Sortierungen und Lookup-Index.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
percentDifference
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup index
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Eine aggregierte Kennzahl, für die Sie die prozentuale Differenz sehen möchten.
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*lookup index*
Der Lookup-Index kann positiv (nachfolgende Zeile in der Sortierung) oder negativ (vorherige Zeile in der Sortierung) sein. Der Lookup-Index kann 1–2 147 483 647 sein. Für die Engines MySQL, MariaDB und die MySQL-kompatible Aurora-Edition ist der Lookup-Index auf 1 beschränkt.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet die prozentuale Differenz zwischen `sum(Sales)` für den aktuellen und vorherigen `State`, sortiert nach `Sales`.
```
percentDifference
(
sum(amount),
[sum(amount) ASC],
-1,
[State]
)
```
Das folgende Beispiel berechnet den prozentualen Anteil eines bestimmten `Billed Amount` an einem anderen `Billed Amount`, sortiert nach (`[{Customer Region} ASC]`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
percentDifference
(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels. Die roten Buchstaben zeigen, dass die Summe `Billed Amount` für `Customer Region` **APAC** 24 Prozent unter dem Betrag für die Region **EMEA** liegt.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/percentDifference.png)
# avgOver
Die Funktion `avgOver` berechnet den Durchschnitt eines Messwerts, partitioniert über eine Liste von Dimensionen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
avgOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
Das folgende Beispiel zeigt den Durchschnitt von `Billed Amount` über `Customer Region` an. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
avgOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels. Mit der Addition von `Service Line` wird jeweils der Gesamtbetrag angezeigt. Der Durchschnitt dieser drei Werte wird im berechneten Feld angezeigt.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/avgOver.png)
## Argumente
*measure*
Die Metrik, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel ruft den Durchschnitt von `sum(Sales)` ab, partitioniert nach `City` und `State`.
```
avgOver
(
sum(Sales),
[City, State]
)
```
# countOver
Die Funktion `countOver` berechnet die Anzahl einer Dimension oder eines Messwerts, die durch eine Liste von Dimensionen partitioniert ist.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
countOver
(
measure or dimension field
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure or dimension field (Metrik- oder Dimensionsfeld)*
Die Metrik oder die Dimension, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Im folgenden Beispiel wird die Anzahl von `Sales` abgerufen, partitioniert über `City` und `State`.
```
countOver
(
Sales,
[City, State]
)
```
Im folgenden Beispiel wird die Anzahl von `{County}` abgerufen, partitioniert über `City` und `State`.
```
countOver
(
{County},
[City, State]
)
```
Das folgende Beispiel zeigt die Anzahl von `Billed Amount` über `Customer Region` an. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
countOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels. Da es keine weiteren Felder gibt, ist die Anzahl für jede Region eins.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/countOver1.png)
Wenn Sie zusätzliche Felder hinzufügen, ändert sich die Anzahl. Im folgenden Screenshot fügen wir `Customer Segment` und `Service Line` hinzu. Jedes dieser Felder enthält drei eindeutige Werte. Bei 3 Segmenten, 3 Servicezeilen und 3 Regionen zeigt das berechnete Feld 9 an.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/countOver2.png)
Wenn Sie die beiden zusätzlichen Felder zu den Partitionierungsfeldern im berechneten Feld `countOver( sum({Billed Amount}), [{Customer Region}, {Customer Segment}, {Service Line}]` hinzufügen, ist die Anzahl wieder 1 für jede Zeile.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/countOver.png)
# maxOver
Die Funktion `maxOver` berechnet das Maximum eines Messwerts oder Datums, partitioniert durch eine Liste von Dimensionen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
maxOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure*
Die Metrik, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel berechnet das Maximum von `sum(Sales)`, partitioniert nach `City` und `State`.
```
maxOver
(
sum(Sales),
[City, State]
)
```
Das folgende Beispiel zeigt das Maximum von `Billed Amount` für `Customer Region` an. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
maxOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels. Mit der Addition von `Service Line` wird jeweils der Gesamtbetrag angezeigt. Das Maximum dieser drei Werte wird im berechneten Feld angezeigt.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/maxOver.png)
# minOver
Die Funktion `minOver` berechnet das Minimum eines Messwerts oder Datums, partitioniert durch eine Liste von Dimensionen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
minOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure*
Die Metrik, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel berechnet den Min.-Wert von `sum(Sales)`, partitioniert nach `City` und `State`.
```
minOver
(
sum(Sales),
[City, State]
)
```
Das folgende Beispiel zeigt das Minimum von `Billed Amount` für `Customer Region` an. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
minOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels. Mit der Addition von `Service Line` wird jeweils der Gesamtbetrag angezeigt. Das Minimum dieser drei Werte wird im berechneten Feld angezeigt.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/minOver.png)
# percentileOver
Die Funktion `percentileOver` berechnet das *n.* Perzentil eines Messwerts, das durch eine Liste von Dimensionen partitioniert ist. In Quick sind zwei Varianten der `percentileOver` Berechnung verfügbar:
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html) verwendet lineare Interpolation, um das Ergebnis zu ermitteln.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html) verwendet tatsächliche Werte, um das Ergebnis zu ermitteln.
Die `percentileOver`-Funktion ist ein Alias von `percentileDiscOver`.
# percentileContOver
Die `percentileContOver`-Funktion berechnet das Perzentil auf der Grundlage der tatsächlichen Zahlen in `measure`. Sie verwendet die Gruppierung und Sortierung, die in den Feldbereichen angewendet werden. Das Ergebnis wird nach der angegebenen Dimension auf der angegebenen Berechnungsebene aufgeteilt.
Verwenden Sie diese Funktion, um die folgende Frage zu beantworten: Welche tatsächlichen Datenpunkte befinden sich in diesem Perzentil? Um den nächstgelegenen Perzentilwert, der in Ihrem Datensatz vorhanden ist, zurückzugeben, verwenden Sie `percentileDiscOver`. Um einen exakten Perzentilwert zurückzugeben, der in Ihrem Datensatz möglicherweise nicht vorhanden ist, verwenden Sie stattdessen `percentileContOver`.
## Syntax
```
percentileContOver (
measure
, percentile-n
, [partition-by, …]
, calculation-level
)
```
## Argumente
*measure*
Gibt einen numerischen Wert an, der zur Berechnung des Perzentils verwendet werden soll. Das Argument muss ein Maß oder eine Metrik sein. Null-Werte werden bei der Berechnung ignoriert.
*Perzentil-n*
Der Perzentilwert kann eine beliebige numerische Konstante von 0–100 sein. Ein Perzentilwert von 50 berechnet den Medianwert des Maßes.
*partition-by*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas. Jedes Feld in der Liste ist in \$1 \$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation-level*
Gibt an, wo die Berechnung in Bezug auf die Reihenfolge der Auswertung durchgeführt werden soll. Es werden drei Berechnungsebenen unterstützt:
+ PRE\$1FILTER
+ PRE\$1AGG
+ POST\$1AGG\$1FILTER (Standard) – Um diese Berechnungsebene zu verwenden, geben Sie beispielsweise eine Aggregation auf `measure` an, z. B. `sum(measure)`.
PRE\$1FILTER und PRE\$1AGG werden angewendet, bevor die Aggregation in einer Visualisierung erfolgt. Für diese beiden Berechnungsebenen können Sie im Ausdruck des berechneten Feldes keine Aggregation für `measure` angeben. Weitere Informationen zu Berechnungsebenen und wann sie gelten, finden Sie unter [Reihenfolge der Bewertung in Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/order-of-evaluation-quicksight.html) und [Verwenden von stufenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Rückgabewert
Das Ergebnis der Funktion ist eine Zahl.
## Beispiele für percentileContOver
Das folgende Beispiel erklärt, wie percentileContOver das funktioniert.
**Example Vergleich der Berechnungsebenen für den Median**
Das folgende Beispiel zeigt den Median für eine Dimension (Kategorie) unter Verwendung verschiedener Berechnungsebenen mit der `percentileContOver`-Funktion. Das Perzentil ist 50. Der Datensatz wird nach einem Regionsfeld gefiltert. Der Code für jedes berechnete Feld lautet wie folgt:
+ `example = left( category, 1 )` (Ein vereinfachtes Beispiel.)
+ `pre_agg = percentileContOver ( {Revenue} , 50 , [ example ] , PRE_AGG)`
+ `pre_filter = percentileContOver ( {Revenue} , 50 , [ example ] , PRE_FILTER) `
+ `post_agg_filter = percentileContOver ( sum ( {Revenue} ) , 50 , [ example ], POST_AGG_FILTER )`
```
example pre_filter pre_agg post_agg_filter
------------------------------------------------------
0 106,728 119,667 4,117,579
1 102,898 95,946 2,307,547
2 97,807 93,963 554,570
3 101,043 112,585 2,709,057
4 96,533 99,214 3,598,358
5 106,293 97,296 1,875,648
6 97,118 69,159 1,320,672
7 100,201 90,557 969,807
```
# percentileDiscOver
Die `percentileDiscOver`-Funktion berechnet das Perzentil auf der Grundlage der tatsächlichen Zahlen in `measure`. Sie verwendet die Gruppierung und Sortierung, die in den Feldbereichen angewendet werden. Das Ergebnis wird nach der angegebenen Dimension auf der angegebenen Berechnungsebene aufgeteilt. Die `percentileOver`-Funktion ist ein Alias von `percentileDiscOver`.
Verwenden Sie diese Funktion, um die folgende Frage zu beantworten: Welche tatsächlichen Datenpunkte befinden sich in diesem Perzentil? Um den nächstgelegenen Perzentilwert, der in Ihrem Datensatz vorhanden ist, zurückzugeben, verwenden Sie `percentileDiscOver`. Um einen exakten Perzentilwert zurückzugeben, der in Ihrem Datensatz möglicherweise nicht vorhanden ist, verwenden Sie stattdessen `percentileContOver`.
## Syntax
```
percentileDiscOver (
measure
, percentile-n
, [partition-by, …]
, calculation-level
)
```
## Argumente
*measure*
Gibt einen numerischen Wert an, der zur Berechnung des Perzentils verwendet werden soll. Das Argument muss ein Maß oder eine Metrik sein. Null-Werte werden bei der Berechnung ignoriert.
*Perzentil-n*
Der Perzentilwert kann eine beliebige numerische Konstante von 0–100 sein. Ein Perzentilwert von 50 berechnet den Medianwert des Maßes.
*partition-by*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas. Jedes Feld in der Liste ist in \$1 \$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation-level*
Gibt an, wo die Berechnung in Bezug auf die Reihenfolge der Auswertung durchgeführt werden soll. Es werden drei Berechnungsebenen unterstützt:
+ PRE\$1FILTER
+ PRE\$1AGG
+ POST\$1AGG\$1FILTER (Standard) – Um diese Berechnungsebene zu verwenden, müssen Sie eine Aggregation auf `measure` angeben, z. B. `sum(measure)`.
PRE\$1FILTER und PRE\$1AGG werden angewendet, bevor die Aggregation in einer Visualisierung erfolgt. Für diese beiden Berechnungsebenen können Sie im Ausdruck des berechneten Feldes keine Aggregation für `measure` angeben. Weitere Informationen zu Berechnungsebenen und wann sie gelten, finden Sie unter [Reihenfolge der Bewertung in Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/order-of-evaluation-quicksight.html) und [Verwenden von stufenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Rückgabewert
Das Ergebnis der Funktion ist eine Zahl.
## Beispiele für percentileDiscOver
Das folgende Beispiel erklärt, wie percentileDiscOver das funktioniert.
**Example Vergleich der Berechnungsebenen für den Median**
Das folgende Beispiel zeigt den Median für eine Dimension (Kategorie) unter Verwendung verschiedener Berechnungsebenen mit der `percentileDiscOver`-Funktion. Das Perzentil ist 50. Der Datensatz wird nach einem Regionsfeld gefiltert. Der Code für jedes berechnete Feld lautet wie folgt:
+ `example = left( category, 1 )` (Ein vereinfachtes Beispiel.)
+ `pre_agg = percentileDiscOver ( {Revenue} , 50 , [ example ] , PRE_AGG)`
+ `pre_filter = percentileDiscOver ( {Revenue} , 50 , [ example ] , PRE_FILTER) `
+ `post_agg_filter = percentileDiscOver ( sum ( {Revenue} ) , 50 , [ example ], POST_AGG_FILTER )`
```
example pre_filter pre_agg post_agg_filter
------------------------------------------------------
0 106,728 119,667 4,117,579
1 102,898 95,946 2,307,547
2 97,629 92,046 554,570
3 100,867 112,585 2,709,057
4 96,416 96,649 3,598,358
5 106,293 97,296 1,875,648
6 97,118 64,395 1,320,672
7 99,915 90,557 969,807
```
**Example Der Median**
Das folgende Beispiel berechnet den Medianwert (das 50. Perzentil) von `Sales`, partitioniert nach `City` und `State`.
```
percentileDiscOver
(
Sales,
50,
[City, State]
)
```
Das folgende Beispiel berechnet das 98. Perzentil von `sum({Billed Amount})`, partitioniert nach `Customer Region`. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
percentileDiscOver
(
sum({Billed Amount}),
98,
[{Customer Region}]
)
```
Die folgende Abbildung zeigt, wie diese beiden Beispiele in einem Diagramm aussehen.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/percentilOver-50-98.png)
# percentOfTotal
Die Funktion `percentOfTotal` berechnet den Prozentsatz, den ein Messwert zur Summe beiträgt, basierend auf den angegebenen Dimensionen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
percentOfTotal
(
measure
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Eine aggregierte Kennzahl, für die Sie den prozentualen Anteil am Gesamtwert sehen möchten. Derzeit wird die `distinct count`-Aggregation für `percentOfTotal` nicht unterstützt.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel erstellt eine Berechnung für den prozentualen Anteil jedes `Sales` an der Gesamtsumme `State`.
```
percentOfTotal
(
sum(Sales),
[State]
)
```
Das folgende Beispiel berechnet den prozentualen Anteil eines bestimmten `Billed Amount` im Vergleich zur Summe `Billed Amount`, partitioniert durch (`[{Service Line} ASC]`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
percentOfTotal
(
sum( {Billed Amount} ),
[{Service Line}]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels. Die roten Markierungen zeigen, dass das Partitionsfeld mit dem Wert "`Billing`" drei Einträge hat, einen für jede Region. Der Gesamtbetrag für diese Servicezeile wird in drei Prozentsätze aufgeteilt, die sich auf 100 Prozent belaufen. Die Prozentangaben sind gerundet und ergeben nicht immer genau 100 Prozent.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/percentOfTotal.png)
# periodOverPeriodDifference
Die `periodOverPeriodDifference`-Funktion berechnet die Differenz eines Messwertes über zwei verschiedene Zeiträume, die durch die Periodengranularität und den Offset spezifiziert werden. Im Gegensatz zu einer Differenzberechnung verwendet diese Funktion einen datumsbasierten Offset anstelle eines Offsets mit fester Größe. Dadurch wird sichergestellt, dass nur die richtigen Daten verglichen werden, auch wenn Datenpunkte im Datensatz fehlen.
## Syntax
```
periodOverPeriodDifference(
measure,
date,
period,
offset)
```
## Argumente
*measure*
Eine aggregierte Kennzahl, für die Sie die periodOverPeriod Berechnung durchführen möchten.
*dateTime*
Die Datumsdimension, für die wir Period-Over-Period Berechnungen berechnen.
*Zeitraum*
(Optional) Der Zeitraum, für den Sie die Berechnung berechnen. Granularität von `YEAR` bedeutet die Berechnung von `YearToDate`, `Quarter` bedeutet `QuarterToDate` und so weiter. Zu den gültigen Granularitäten gehören `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` und `SECONDS`.
Der Standardwert ist die Granularität der visuellen Datumsdimension.
*offset*
(Optional) Der Offset kann eine positive oder negative Ganzzahl sein, die den vorherigen Zeitraum (angegeben durch den Zeitraum) darstellt, mit dem Sie vergleichen möchten. So bedeutet beispielsweise der Zeitraum eines Quartals mit dem Offset 1 einen Vergleich mit dem vorhergehenden Quartal.
Der Standardwert ist 1.
## Beispiel
Das folgende Beispiel verwendet ein berechnetes Feld `PeriodOverPeriod`, um die Umsatzdifferenz von gestern anzuzeigen
```
periodOverPeriodDifference(sum(Sales), {Order Date})
```
![\[Dies ist ein Bild des Ergebnisses der Beispielrechnung.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/MonthOverMonthDifference.png)
Im folgenden Beispiel wird ein berechnetes Feld `PeriodOverPeriod` verwendet, um die Umsatzdifferenz der letzten 2 Monate anzuzeigen. Untenstehendes Beispiel vergleicht die Umsätze von `Mar2020` mit `Jan2020`.
```
periodOverPeriodDifference(sum(Sales),{Order Date}, MONTH, 1)
```
![\[Dies ist ein Bild des Ergebnisses der Beispielrechnung.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/MonthOverMonthDifference2.png)
# periodOverPeriodLastValue
Die `periodOverPeriodLastValue`-Funktion berechnet den letzten (vorherigen) Wert eines Messwertes aus dem vorangegangenen Zeitraum, der durch die Periodengranularität und den Offset festgelegt ist. Diese Funktion verwendet einen datumsbasierten Offset anstelle eines Offsets mit fester Größe. Dadurch wird sichergestellt, dass nur die richtigen Daten verglichen werden, auch wenn Datenpunkte im Datensatz fehlen.
## Syntax
```
periodOverPeriodLastValue(
measure,
date,
period,
offset)
```
## Argumente
*measure*
Eine aggregierte Kennzahl, für die Sie die Differenz sehen möchten.
*date*
Die Datumsdimension, für die Sie periodOverPeriod Berechnungen berechnen.
*Zeitraum*
(Optional) Der Zeitraum, für den Sie die Berechnung berechnen. Granularität von `YEAR` bedeutet die Berechnung von `YearToDate`, `Quarter` bedeutet `QuarterToDate` und so weiter. Zu den gültigen Granularitäten gehören `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` und `SECONDS`.
Dieses Argument verwendet standardmäßig die Granularität der visuellen Aggregation
*offset*
(Optional) Der Offset kann eine positive oder negative Ganzzahl sein, die den vorherigen Zeitraum (angegeben durch den Zeitraum) darstellt, mit dem Sie vergleichen möchten. So bedeutet beispielsweise der Zeitraum eines Quartals mit dem Offset 1 einen Vergleich mit dem vorhergehenden Quartal.
Der Standardwert für dieses Argument ist 1.
## Beispiel
Im folgenden Beispiel wird der Wert für Verkäufe von Monat zu Monat mit der Granularität der visuellen Dimension und dem Standardoffset von 1 berechnet.
```
periodOverPeriodLastValue(sum(Sales), {Order Date})
```
Im folgenden Beispiel wird der monatliche Wert der Verkäufe mit einer festen Granularität von `MONTH` und einem festen Offset von 1 berechnet.
```
periodOverPeriodLastValue(sum(Sales), {Order Date},MONTH, 1)
```
![\[Dies ist ein Bild des Ergebnisses der Beispielrechnung.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/MonthOverMonthLastValue.png)
# periodOverPeriodPercentDifference
Die `periodOverPeriodPercentDifference`-Funktion berechnet die prozentuale Differenz eines Messwertes über zwei verschiedene Zeiträume, die durch die Periodengranularität und den Offset spezifiziert werden. Im Gegensatz zu percentDifference verwendet diese Funktion einen datumsbasierten Offset anstelle eines Offsets mit fester Größe. Dadurch wird sichergestellt, dass nur die richtigen Daten verglichen werden, auch wenn Datenpunkte im Datensatz fehlen.
## Syntax
```
periodOverPeriodPercentDifference(
measure,
date,
period,
offset)
```
## Argumente
*measure*
Eine aggregierte Kennzahl, für die Sie die Differenz sehen möchten.
*date*
Die Datumsdimension, für die Sie periodOverPeriod Berechnungen berechnen.
*Zeitraum*
(Optional) Der Zeitraum, für den Sie die Berechnung berechnen. Granularität von `YEAR` bedeutet die Berechnung von `YearToDate`, `Quarter` bedeutet `QuarterToDate` und so weiter. Zu den gültigen Granularitäten gehören `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` und `SECONDS`.
Dieses Argument verwendet standardmäßig die Granularität der visuellen Aggregation
*offset*
(Optional) Der Offset kann eine positive oder negative Ganzzahl sein, die den vorherigen Zeitraum (angegeben durch den Zeitraum) darstellt, mit dem Sie vergleichen möchten. So bedeutet beispielsweise der Zeitraum eines Quartals mit dem Offset 1 einen Vergleich mit dem vorhergehenden Quartal.
Der Standardwert für dieses Argument ist 1.
## Beispiel
Im folgenden Beispiel wird der prozentuale Umsatzunterschied von Monat zu Monat mit der Granularität der visuellen Dimension und dem Standardversatz von 1 berechnet.
```
periodOverPeriodPercentDifference(sum(Sales),{Order Date})
```
Das folgende Beispiel berechnet die prozentuale Differenz der Umsätze von Monat zu Monat mit einer festen Granularität von `MONTH` und einem festen Offset von 1.
```
periodOverPeriodPercentDifference(sum(Sales), {Order Date}, MONTH, 1)
```
![\[Dies ist ein Bild des Ergebnisses der Beispielrechnung.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/MonthOverMonthPercentDifference.png)
# periodToDateAvgOverTime
Die Funktion `periodToDateAvgOverTime` berechnet den Durchschnitt eines Messwertes für eine bestimmte Zeitgranularität (z. B. ein Quartal) bis zu einem bestimmten Zeitpunkt.
## Syntax
```
periodToDateAvgOverTime(
measure,
dateTime,
period)
```
## Argumente
*measure*
Ein aggregierter Messwert, mit dem Sie die Berechnung durchführen möchten
*dateTime*
Die Datumsdimension, für die Sie PeriodOverTime Berechnungen berechnen.
*Zeitraum*
(Optional) Der Zeitraum, für den Sie die Berechnung berechnen. Granularität von `YEAR` bedeutet die Berechnung von `YearToDate`, `Quarter` bedeutet `QuarterToDate` und so weiter. Zu den gültigen Granularitäten gehören `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` und `SECONDS`.
Der Standardwert ist die Granularität der Datumsdimension des Bildmaterials.
## Beispiel
Die folgende Funktion berechnet den durchschnittlichen Tarif für jeden Monat.
```
periodToDateAvgOverTime(sum({fare_amount}), pickupDatetime, MONTH)
```
![\[Dies ist eine Abbildung der Ergebnisse der Beispielrechnung mit Illustrationen.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/PTDAvgOverTimeResults.png)
# periodToDateCountOverTime
Die Funktion `periodToDateCountOverTime` berechnet die Anzahl einer Dimension oder eines Messwertes für eine bestimmte zeitliche Granularität (z. B. ein Quartal) bis zu einem bestimmten Zeitpunkt.
## Syntax
```
periodToDateCountOverTime(
measure,
dateTime,
period)
```
## Argumente
*measure*
Ein aggregierter Messwert, mit dem Sie die Berechnung durchführen möchten
*dateTime*
Die Datumsdimension, für die Sie PeriodOverTime Berechnungen berechnen.
*Zeitraum*
(Optional) Der Zeitraum, für den Sie die Berechnung berechnen. Granularität von `YEAR` bedeutet die Berechnung von `YearToDate`, `Quarter` bedeutet `QuarterToDate` und so weiter. Zu den gültigen Granularitäten gehören `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` und `SECONDS`.
Der Standardwert ist die Granularität der Datumsdimension des Bildmaterials.
## Beispiel
Im folgenden Beispiel wird die Anzahl der Anbieter für jeden Monat berechnet.
```
periodToDateCountOverTime(count(vendorid), pickupDatetime, MONTH)
```
![\[Dies ist eine Abbildung der Ergebnisse der Beispielrechnung mit Illustrationen.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/PTDCountOverTimeResults.png)
# periodToDateMaxOverTime
Die Funktion `periodToDateMaxOverTime` berechnet das Maximum eines Messwertes für eine bestimmte Zeitgranularität (z. B. ein Quartal) bis zu einem bestimmten Zeitpunkt.
## Syntax
```
periodToDateMaxOverTime(
measure,
dateTime,
period)
```
## Argumente
*measure*
Ein aggregierter Messwert, mit dem Sie die Berechnung durchführen möchten
*dateTime*
Die Datumsdimension, für die Sie PeriodOverTime Berechnungen berechnen.
*Zeitraum*
(Optional) Der Zeitraum, für den Sie die Berechnung berechnen. Granularität von `YEAR` bedeutet die Berechnung von `YearToDate`, `Quarter` bedeutet `QuarterToDate` und so weiter. Zu den gültigen Granularitäten gehören `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` und `SECONDS`.
Der Standardwert ist die Granularität der Datumsdimension des Bildmaterials.
## Beispiel
Im folgenden Beispiel wird der maximale Tarif für jeden Monat berechnet.
```
periodToDatemaxOverTime(max({fare_amount}), pickupDatetime, MONTH)
```
![\[Dies ist eine Abbildung der Ergebnisse der Beispielrechnung mit Illustrationen.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/PTDMaxOverTimeResults.png)
# periodToDateMinOverTime
Die Funktion `periodToDateMinOverTime` berechnet das Minimum eines Messwertes für eine bestimmte Zeitgranularität (z. B. ein Quartal) bis zu einem bestimmten Zeitpunkt.
## Syntax
```
periodToDateMinOverTime(
measure,
dateTime,
period)
```
## Argumente
*measure*
Ein aggregierter Messwert, mit dem Sie die Berechnung durchführen möchten
*dateTime*
Die Datumsdimension, für die Sie PeriodOverTime Berechnungen berechnen.
*Zeitraum*
(Optional) Der Zeitraum, für den Sie die Berechnung berechnen. Granularität von `YEAR` bedeutet die Berechnung von `YearToDate`, `Quarter` bedeutet `QuarterToDate` und so weiter. Zu den gültigen Granularitäten gehören `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` und `SECONDS`.
Der Standardwert ist die Granularität der Datumsdimension des Bildmaterials.
## Beispiel
Im folgenden Beispiel wird der Mindesttarif Monat für Monat berechnet.
```
periodToDateMinOverTime(min({fare_amount}), pickupDatetime, MONTH)
```
![\[Dies ist eine Abbildung der Ergebnisse der Beispielrechnung mit Illustrationen.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/PTDMinOverTimeResults.png)
# periodToDateSumOverTime
Die Funktion `periodToDateSumOverTime` berechnet die Summe eines Messwertes für eine bestimmte Zeitgranularität (z. B. ein Quartal) bis zu einem bestimmten Zeitpunkt.
## Syntax
```
periodToDateSumOverTime(
measure,
dateTime,
period)
```
## Argumente
*measure*
Ein aggregierter Messwert, mit dem Sie die Berechnung durchführen möchten
*dateTime*
Die Datumsdimension, für die Sie PeriodOverTime Berechnungen berechnen.
*Zeitraum*
(Optional) Der Zeitraum, für den Sie die Berechnung berechnen. Granularität von `YEAR` bedeutet die Berechnung von `YearToDate`, `Quarter` bedeutet `QuarterToDate` und so weiter. Zu den gültigen Granularitäten gehören `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` und `SECONDS`.
Der Standardwert ist die Granularität der Datumsdimension des Bildmaterials.
## Beispiel
Die folgende Funktion gibt den Gesamttarif für jeden Monat zurück.
```
periodToDateSumOverTime(sum({fare_amount}), pickupDatetime, MONTH)
```
![\[Dies ist eine Abbildung der Ergebnisse der Beispielrechnung mit Illustrationen.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/PTDSumOverTime-example-results.png)
# stdevOver
Die Funktion `stdevOver` berechnet anhand einer Stichprobe die Standardabweichung der angegebenen Messung, partitioniert in das/die ausgewählte(n) Attribut(e).
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
stdevOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure*
Die Metrik, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard)-Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel berechnet anhand einer Stichprobe die Standardabweichung von `sum(Sales)`, partitioniert in `City` und `State`.
```
stdevOver
(
sum(Sales),
[City, State]
)
```
Das folgende Beispiel berechnet anhand einer Stichprobe die Standardabweichung von `Billed Amount` über `Customer Region`. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
stdevOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# stdevpOver
Die Funktion `stdevpOver` berechnet anhand einer Population mit Bias die Standardabweichung der angegebenen Messung, partitioniert in das/die ausgewählte(n) Attribut(e).
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
stdevpOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure*
Die Metrik, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard)-Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel berechnet anhand einer Population mit Bias die Standardabweichung von `sum(Sales)`, partitioniert in `City` und `State`.
```
stdevpOver
(
sum(Sales),
[City, State]
)
```
Das folgende Beispiel berechnet anhand einer Population mit Bias die Standardabweichung von `Billed Amount` über `Customer Region`. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
stdevpOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# varOver
Die Funktion `varOver` berechnet anhand einer Stichprobe die Varianz der angegebenen Messung, partitioniert in das/die gewählte(n) Attribut(e).
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
varOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure*
Die Metrik, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel berechnet anhand einer Stichprobe die Varianz von `sum(Sales)`, partitioniert in `City` und `State`.
```
varOver
(
sum(Sales),
[City, State]
)
```
Das folgende Beispiel berechnet anhand einer Stichprobe die Varianz von `Billed Amount` über `Customer Region`. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
varOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# varpOver
Die Funktion `varpOver` berechnet anhand einer Population mit Bias die Varianz der angegebenen Messung, partitioniert in das/die ausgewählte(n) Attribut(e).
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
varpOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure*
Die Metrik, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel berechnet anhand einer Population mit Bias die Varianz von `sum(Sales)`, partitioniert in `City` und `State`.
```
varpOver
(
sum(Sales),
[City, State]
)
```
Das folgende Beispiel berechnet anhand einer Population mit Bias die Varianz von `Billed Amount` über `Customer Region`. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
varpOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# sumOver
Die Funktion `sumOver` berechnet die Summe eines Maßes, das durch eine Liste von Dimensionen partitioniert ist.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
sumOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumente
*measure*
Die Metrik, für die Sie die Berechnung durchführen möchten, z. B. `sum({Sales Amt})`. Verwenden Sie eine Aggregation, wenn die Berechnungsebene auf `NULL` oder `POST_AGG_FILTER` festgelegt ist. Verwenden Sie keine Aggregation, wenn die Berechnungsebene auf `PRE_FILTER` oder `PRE_AGG` festgelegt ist.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard)-Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel berechnet die Summe von `sum(Sales)`, partitioniert nach `City` und `State`.
```
sumOver
(
sum(Sales),
[City, State]
)
```
Das folgende Beispiel summiert `Billed Amount` über `Customer Region`. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
sumOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels. Mit der Addition von `Customer Segment` wird der jeweils berechnete Gesamtbetrag für die `Customer Region` aufsummiert und im berechneten Feld angezeigt.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/sumOver.png)
# denseRank
Die Funktion `denseRank` berechnet den Rang eines Messwertes oder einer Dimension im Vergleich zu den angegebenen Partitionen. Zählt jedes Element nur einmal, ignoriert Duplikate und weist einen Rang "ohne Leerstellen" zu, sodass doppelte Werte den gleichen Rang haben.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
denseRank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumente
*Sortierreihenfolge-Feld*
Eines oder mehrere aggregierte Felder (Messwerte und/oder Dimensionen), nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel ordnet `max(Sales)`, basierend auf einer absteigenden Sortierung, verdichtet nach `State` und `City`. Alle Städte mit dem gleichen `max(Sales)` erhalten den gleichen Rang. Die nächste Stadt wird nach diesen eingestuft. Wenn sich beispielsweise drei Städte die gleiche Rangfolge teilen, wird die vierte Stadt auf Rang 2 eingestuft.
```
denseRank
(
[max(Sales) DESC],
[State, City]
)
```
Das folgende Beispiel ordnet `max(Sales)`, basierend auf einer absteigenden Sortierung, verdichtet nach `State`. Alle Staaten mit dem gleichen `max(Sales)` erhalten den gleichen Rang. Der nächste wird nach diesen eingestuft. Wenn sich beispielsweise drei Staaten die gleiche Rangfolge teilen, wird der vierte Staat auf Rang 2 eingestuft.
```
denseRank
(
[max(Sales) DESC],
[State]
)
```
# rank
Die Funktion `rank` berechnet den Rang eines Messwertes oder einer Dimension im Vergleich zu den angegebenen Partitionen. Es zählt jedes Element, auch Duplikate, einmal und vergibt einen Rang "mit Leerstellen", um doppelte Werte auszugleichen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
rank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumente
*Sortierreihenfolge-Feld*
Einer oder mehrere aggregierte Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen Berechnungen in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Beispiel
Das folgende Beispiel ordnet `max(Sales)`, basierend auf einer absteigenden Sortierung, nach `State` und `City` innerhalb des `State` von **WA**. Alle Städte mit demselben `max(Sales)` erhalten den gleichen Rang, aber der nächste Rang enthält die Anzahl aller bereits vorhandenen Ränge. Wenn sich beispielsweise drei Städte die gleiche Rangfolge teilen, wird die vierte Stadt auf Rang 4 eingestuft.
```
rank
(
[max(Sales) DESC],
[State, City]
)
```
Das folgende Beispiel ordnet `max(Sales)`, basierend auf einer aufsteigenden Sortierung nach `State`. Alle Staaten mit demselben `max(Sales)` erhalten den gleichen Rang, aber der nächste Rang enthält die Anzahl aller bereits vorhandenen Ränge. Wenn sich beispielsweise drei Staaten die gleiche Rangfolge teilen, wird der vierte Staat auf Rang 4 eingestuft.
```
rank
(
[max(Sales) ASC],
[State]
)
```
Das folgende Beispiel ordnet `Customer Region` nach der Summe `Billed Amount`. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
rank(
[sum({Billed Amount}) DESC]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels zusammen mit der Summe `Billed Amount`, sodass Sie sehen können, wie jede Region eingeordnet ist.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/rankCalc.png)
# percentileRank
Die Funktion `percentileRank` berechnet den Perzentil-Rang eines Messwertes oder einer Dimension im Vergleich zu den angegebenen Partitionen. Der Perzentilrangwert (*x*) gibt an, dass das aktuelle Element über*x*% der Werte in der angegebenen Partition liegt. Der Perzentilrangwert liegt im Bereich von (einschließlich) 0 bis (ausschließlich) 100.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
percentileRank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ {partition_field}, ... ]
)
```
## Argumente
*Sortierreihenfolge-Feld*
Einer oder mehrere aggregierte Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*calculation level (Berechnungsebene)*
(Optional) Gibt die zu verwendende Berechnungsebene an:
+ **`PRE_FILTER`** – Vorfilterberechnungen werden vor den Datensatzfiltern berechnet.
+ **`PRE_AGG`** – Voraggregatberechnungen werden berechnet, bevor die Aggregationen und Top- und Bottom-*N*-Filter auf die Visuals angewendet werden.
+ **`POST_AGG_FILTER`** – (Standard) Tabellenberechnungen werden berechnet, wenn die Visuals angezeigt werden.
Dieser Wert wird standardmäßig auf `POST_AGG_FILTER` eingestellt, wenn er leer ist. Weitere Informationen finden Sie unter [Verwenden von ebenenspezifischen](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html) Berechnungen in Quick.
## Beispiel
Das folgende Beispiel führt eine Perzentilrangeinstufung von `max(Sales)` in absteigender Reihenfolge über `State` durch.
```
percentileRank
(
[max(Sales) DESC],
[State]
)
```
Das folgende Beispiel führt eine Perzentilrangeinstufung von `Customer Region` über den Gesamtwert von `Billed Amount` durch. Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
percentileRank(
[sum({Billed Amount}) DESC],
[{Customer Region}]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels zusammen mit der Summe `Billed Amount`, sodass Sie sehen können, wie jede Region im Vergleich abschneidet.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/percentileRank.png)
# runningAvg
Die Funktion `runningAvg` berechnet einen laufenden Durchschnitt für einen Messwert auf Basis der angegebenen Dimensionen und Sortierungen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
runningAvg
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Ein aggregierter Messwert, für den Sie den laufenden Durchschnitt sehen möchten.
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet einen laufenden Durchschnitt von `sum(Sales)`, sortiert nach `Sales` und partitioniert nach `City` sowie `State`.
```
runningAvg
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
Das folgende Beispiel berechnet einen laufenden Durchschnitt von `Billed Amount`, sortiert nach Monat (`[truncDate("MM",Date) ASC]`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
runningAvg
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningCount
Die Funktion `runningCount` berechnet eine laufende Anzahl für einen Messwert oder eine Dimension auf Basis der angegebenen Dimensionen und Sortierungen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
runningCount
(
measure_or_dimension
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumente
*Messwert oder Dimension*
Ein aggregierter Messwert oder eine Dimension, für die Sie die laufende Anzahl sehen möchten.
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet eine laufende Anzahl von `sum(Sales)`, sortiert nach `Sales` und partitioniert nach `City` sowie `State`.
```
runningCount
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
Das folgende Beispiel berechnet eine laufende Anzahl von `Billed Amount`, sortiert nach Monat (`[truncDate("MM",Date) ASC]`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
runningCount
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningMax
Die Funktion `runningMax` berechnet ein laufendes Maximum für einen Messwert auf Basis der angegebenen Dimensionen und Sortierungen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
runningMax
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Ein aggregierter Messwert, für den Sie das laufende Maximum sehen möchten.
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet ein laufendes Maximum von `sum(Sales)`, sortiert nach `Sales` und partitioniert nach `City` sowie `State`.
```
runningMax
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
Das folgende Beispiel berechnet ein laufendes Maximum von `Billed Amount`, sortiert nach Monat (`[truncDate("MM",Date) ASC]`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
runningMax
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningMin
Die Funktion `runningMin` berechnet ein laufendes Minimum für einen Messwert auf Basis der angegebenen Dimensionen und Sortierungen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
runningMin
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Ein aggregierter Messwert, für den Sie das laufende Minimum sehen möchten.
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet ein laufendes Minimum von `sum(Sales)`, sortiert nach `Sales` und partitioniert nach `City` sowie `State`.
```
runningMin
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
Das folgende Beispiel berechnet ein laufendes Minimum von `Billed Amount`, sortiert nach Monat (`[truncDate("MM",Date) ASC]`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
runningMin
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningSum
Die Funktion `runningSum` berechnet eine laufende Summe für einen Messwert auf Basis der angegebenen Dimensionen und Sortierungen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
runningSum
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Eine aggregierte Kennzahl, für die Sie die laufende Summe sehen möchten.
*Sortierreihenfolge-Feld*
Einer oder mehrere Messwerte und Dimensionen, nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet eine laufende Summe von `sum(Sales)`, sortiert nach `Sales`, partitioniert nach `City` und `State`.
```
runningSum
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
Das folgende Beispiel berechnet eine laufende Summe von `Billed Amount`, sortiert nach Monat (`[truncDate("MM",Date) ASC]`). Die Felder in der Tabellenberechnung befinden sich in den Feldbereichen der Visualisierung.
```
runningSum
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
Der folgende Screenshot zeigt die Ergebnisse des Beispiels. Die roten Beschriftungen zeigen an, wie jeder Betrag ( `a + b = c` ) zum nächsten Betrag addiert wird, was zu einer neuen Summe führt.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/runningSum.png)
# firstValue
Die Funktion `firstValue` berechnet den ersten Wert des aggregierten Messwertes oder der Dimension, partitioniert und sortiert nach den angegebenen Attributen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
firstValue
(
aggregated measure or dimension,
[ sort_attribute ASC_or_DESC, ... ],
[ partition_by_attribute, ... ]
)
```
## Argumente
*aggregierter Messwert oder Dimension*
Ein aggregierter Messwert oder eine Dimension, für die Sie den ersten Wert sehen möchten.
*Attribute sortieren*
Eines oder mehrere aggregierte Felder (Messwerte und/oder Dimensionen), nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*nach Attributen partitionieren*
(Optional) Eine oder mehrere Messwerte oder Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet das erste `Destination Airport`, sortiert nach `Flight Date`, partitioniert nach `Flight Date` aufsteigend und `Origin Airport`.
```
firstValue(
{Destination Airport}
[{Flight Date} ASC],
[
{Origin Airport},
{Flight Date}
]
)
```
# lastValue
Die Funktion `lastValue` berechnet den letzten Wert des aggregierten Messwertes oder der Dimension, partitioniert und sortiert nach den angegebenen Attributen.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
lastValue
(
aggregated measure or dimension,
[ sort_attribute ASC_or_DESC, ... ],
[ partition_by_attribute, ... ]
)
```
## Argumente
*aggregierter Messwert oder Dimension*
Ein aggregierter Messwert oder eine Dimension, für die Sie den letzten Wert sehen möchten.
*Attribute sortieren*
Eines oder mehrere aggregierte Felder (Messwerte und/oder Dimensionen), nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (`ASC`) oder absteigend (`DESC`) sortieren.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*nach Attributen partitionieren*
Einer oder mehrere Messwerte oder Dimensionen, nach denen Sie partitionieren möchten, getrennt durch Kommata.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Im folgenden Beispiel wird der letzte Wert für `Destination Airport` berechnet. Diese Berechnung wird nach dem `Flight Date`-Wert sortiert und durch den `Flight Date`-Wert in aufsteigender Reihenfolge und den `Origin Airport`-Wert unterteilt.
```
lastValue(
[{Destination Airport}],
[{Flight Date} ASC],
[
{Origin Airport},
truncDate('DAY', {Flight Date})
]
)
```
# windowAvg
Die Funktion `windowAvg` berechnet den Durchschnitt des aggregierten Messwerts in einem benutzerdefinierten Fenster, das nach bestimmten Attributen partitioniert und sortiert ist. In der Regel verwenden Sie benutzerdefinierte Fensterfunktionen auf einer Zeitreihe, bei der Ihre Visualisierung eine Metrik und ein Datumsfeld anzeigt. Sie können beispielsweise `windowAvg` verwenden, um einen gleitenden Durchschnitt zu berechnen – häufig verwendet, um Rauschen in einem Liniendiagramm zu glätten.
Fensterfunktionen werden nicht für MySQL-Versionen vor Version 8 und MariaDB-Versionen vor Version 10.2 unterstützt.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
windowAvg
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Die aggregierte Metrik, für die Sie den Durchschnitt erhalten möchten, z. B. `sum({Revenue})`.
*Attribute sortieren*
Eines oder mehrere aggregierte Felder (Messwerte und/oder Dimensionen), nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*Startindex*
Der Startindex ist eine positive Ganzzahl, die *n* Zeilen oberhalb der aktuellen Zeile anzeigt. Der Startindex zählt die verfügbaren Datenpunkte oberhalb der aktuellen Zeile, anstatt tatsächliche Zeiträume zu zählen. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*Endindex*
Der Endindex ist eine positive Ganzzahl, die *n* Zeilen unterhalb der aktuellen Zeile anzeigt. Der Endindex zählt die verfügbaren Datenpunkte unterhalb der aktuellen Zeile anstelle der tatsächlichen Zeiträume. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet den gleitenden Durchschnitt von `sum(Revenue)`, partitioniert nach `SaleDate`. Die Berechnung umfasst drei Zeilen oben und zwei Zeilen unterhalb der aktuellen Zeile.
```
windowAvg
(
sum(Revenue),
[SaleDate ASC],
3,
2
)
```
Die folgende Abbildung zeigt das Ergebnis des Beispiels für einen gleitenden Durchschnitt. Das Feld Summe (Umsatz) wird dem Diagramm hinzugefügt, um die Differenz zwischen dem Umsatz und dem gleitenden Durchschnitt des Umsatzes anzuzeigen.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/windowAvg.png)
# windowCount
Die Funktion `windowCount` berechnet die Anzahl der aggregierten Messwerte oder Dimensionen in einem benutzerdefinierten Fenster, das nach bestimmten Attributen partitioniert und sortiert ist. In der Regel verwenden Sie benutzerdefinierte Fensterfunktionen auf einer Zeitreihe, bei der Ihre Visualisierung eine Metrik und ein Datumsfeld anzeigt.
Fensterfunktionen werden nicht für MySQL-Versionen vor Version 8 und MariaDB-Versionen vor Version 10.2 unterstützt.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
windowCount
(
measure_or_dimension
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumente
*Messwert oder Dimension*
Die aggregierte Metrik, für die Sie den Durchschnitt erhalten möchten, z. B. `sum({Revenue})`.
*Attribute sortieren*
Eines oder mehrere aggregierte Felder (Messwerte und/oder Dimensionen), nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*Startindex*
Der Startindex ist eine positive Ganzzahl, die *n* Zeilen oberhalb der aktuellen Zeile anzeigt. Der Startindex zählt die verfügbaren Datenpunkte oberhalb der aktuellen Zeile, anstatt tatsächliche Zeiträume zu zählen. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*Endindex*
Der Endindex ist eine positive Ganzzahl, die *n* Zeilen unterhalb der aktuellen Zeile anzeigt. Der Endindex zählt die verfügbaren Datenpunkte unterhalb der aktuellen Zeile anstelle der tatsächlichen Zeiträume. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet die gleitende Anzahl von `sum(Revenue)`, partitioniert nach `SaleDate`. Die Berechnung umfasst drei Zeilen oben und zwei Zeilen unterhalb der aktuellen Zeile.
```
windowCount
(
sum(Revenue),
[SaleDate ASC],
3,
2
)
```
# windowMax
Die Funktion `windowMax` berechnet das Maximum des aggregierten Messwerts in einem benutzerdefinierten Fenster, das nach bestimmten Attributen partitioniert und sortiert ist. In der Regel verwenden Sie benutzerdefinierte Fensterfunktionen auf einer Zeitreihe, bei der Ihre Visualisierung eine Metrik und ein Datumsfeld anzeigt. Sie können `windowMax` verwenden, um das Maximum der Metrik über einen bestimmten Zeitraum zu identifizieren.
Fensterfunktionen werden nicht für MySQL-Versionen vor Version 8 und MariaDB-Versionen vor Version 10.2 unterstützt.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
windowMax
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Die aggregierte Metrik, für die Sie den Durchschnitt erhalten möchten, z. B. `sum({Revenue})`.
*Attribute sortieren*
Eines oder mehrere aggregierte Felder (Messwerte und/oder Dimensionen), nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*Startindex*
Der Startindex ist eine positive Ganzzahl, die *n* Zeilen oberhalb der aktuellen Zeile anzeigt. Der Startindex zählt die verfügbaren Datenpunkte oberhalb der aktuellen Zeile, anstatt tatsächliche Zeiträume zu zählen. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*Endindex*
Der Endindex ist eine positive Ganzzahl, die *n* Zeilen unterhalb der aktuellen Zeile anzeigt. Der Endindex zählt die verfügbaren Datenpunkte unterhalb der aktuellen Zeile anstelle der tatsächlichen Zeiträume. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist in \$1\$1 eingeschlossen (geschweifte Klammern), wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet das Maximum der vergangenen zwölf Monate von `sum(Revenue)`, partitioniert nach `SaleDate`. Die Berechnung umfasst 12 Zeilen oberhalb und 0 Zeilen unterhalb der aktuellen Zeile.
```
windowMax
(
sum(Revenue),
[SaleDate ASC],
12,
0
)
```
Der folgende Screenshot zeigt die Ergebnisse dieses Beispiels für die letzten zwölf Monate. Das Feld Summe (Umsatz) wird dem Diagramm hinzugefügt, um die Differenz zwischen dem Umsatz und dem Maximum der vergangenen zwölf Monate anzuzeigen.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/windowMax.png)
# windowMin
Die Funktion `windowMin` berechnet das Minimum des aggregierten Messwerts in einem benutzerdefinierten Fenster, das nach bestimmten Attributen partitioniert und sortiert ist. In der Regel verwenden Sie benutzerdefinierte Fensterfunktionen auf einer Zeitreihe, bei der Ihre Visualisierung eine Metrik und ein Datumsfeld anzeigt. Sie können `windowMin` verwenden, um das Minimum der Metrik über einen bestimmten Zeitraum zu identifizieren.
Fensterfunktionen werden nicht für MySQL-Versionen vor Version 8 und MariaDB-Versionen vor Version 10.2 unterstützt.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
windowMin
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Die aggregierte Metrik, für die Sie den Durchschnitt erhalten möchten, z. B. `sum({Revenue})`.
*Attribute sortieren*
Eines oder mehrere aggregierte Felder (Messwerte und/oder Dimensionen), nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*Startindex*
Der Startindex ist eine positive Ganzzahl, die *n* Zeilen oberhalb der aktuellen Zeile anzeigt. Der Startindex zählt die verfügbaren Datenpunkte oberhalb der aktuellen Zeile, anstatt tatsächliche Zeiträume zu zählen. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*Endindex*
Der Endindex ist eine positive Ganzzahl, die *n* Zeilen unterhalb der aktuellen Zeile anzeigt. Der Endindex zählt die verfügbaren Datenpunkte unterhalb der aktuellen Zeile anstelle der tatsächlichen Zeiträume. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet das Minimum der vergangenen zwölf Monate von `sum(Revenue)`, partitioniert nach `SaleDate`. Die Berechnung umfasst 12 Zeilen oberhalb und 0 Zeilen unterhalb der aktuellen Zeile.
```
windowMin
(
sum(Revenue),
[SaleDate ASC],
12,
0
)
```
Der folgende Screenshot zeigt die Ergebnisse dieses Beispiels für die letzten zwölf Monate. Das Feld Summe (Umsatz) wird dem Diagramm hinzugefügt, um die Differenz zwischen dem Umsatz und dem Minimum der vergangenen zwölf Monate anzuzeigen.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/windowMin.png)
# windowSum
Die Funktion `windowSum` berechnet die Summe des aggregierten Messwerts in einem benutzerdefinierten Fenster, das nach bestimmten Attributen partitioniert und sortiert ist. In der Regel verwenden Sie benutzerdefinierte Fensterfunktionen auf einer Zeitreihe, bei der Ihre Visualisierung eine Metrik und ein Datumsfeld anzeigt.
Fensterfunktionen werden nicht für MySQL-Versionen vor Version 8 und MariaDB-Versionen vor Version 10.2 unterstützt.
## Syntax
Die Klammern sind erforderlich. Welche Argumente optional sind, erfahren Sie in den folgenden Beschreibungen.
```
windowSum
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumente
*measure*
Die aggregierte Metrik, für die Sie die Summe erhalten möchten, z. B. `sum({Revenue})`.
Für die Engines MySQL, MariaDB und Amazon Aurora mit MySQL-Kompatibilität ist der Lookup-Index auf 1 beschränkt. Fensterfunktionen werden nicht für MySQL-Versionen vor Version 8 und MariaDB-Versionen vor Version 10.2 unterstützt.
*Attribute sortieren*
Eines oder mehrere aggregierte Felder (Messwerte und/oder Dimensionen), nach denen Sie die Daten sortieren möchten, getrennt durch Kommas. Sie können aufsteigend (**ASC**) oder absteigend (**DESC**) sortieren.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
*Startindex*
Der Startindex ist eine positive Ganzzahl, die *n* Zeilen oberhalb der aktuellen Zeile anzeigt. Der Startindex zählt die verfügbaren Datenpunkte oberhalb der aktuellen Zeile, anstatt tatsächliche Zeiträume zu zählen. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*Endindex*
Der Endindex ist eine positive Ganzzahl, die *n* Zeilen unterhalb der aktuellen Zeile anzeigt. Der Endindex zählt die verfügbaren Datenpunkte unterhalb der aktuellen Zeile anstelle der tatsächlichen Zeiträume. Sind Ihre Daten unvollständig (beispielsweise fehlende Monate oder Jahre), passen Sie die Indizes entsprechend an.
*partition field*
(Optional) Eine oder mehrere Dimensionen, nach denen Sie die Daten partitionieren möchten, getrennt durch Kommas.
Jedes Feld in der Liste ist von \$1 \$1 (geschweifte Klammern) eingeschlossen, wenn es mehr als ein Wort umfasst. Die gesamte Liste ist in [ ] (eckige Klammern) eingeschlossen.
## Beispiel
Das folgende Beispiel berechnet eine gleitende Summe von `sum(Revenue)`, sortiert nach Monat `SaleDate`. Die Berechnung umfasst zwei Zeilen oberhalb und eine Zeile vor der aktuellen Zeile.
```
windowSum
(
sum(Revenue),
[SaleDate ASC],
2,
1
)
```
Das folgende Beispiel zeigt die Summe der vergangenen 12 Monate.
```
windowSum(sum(Revenue),[SaleDate ASC],12,0)
```
Die folgende Abbildung zeigt das Ergebnis des Beispiels der vergangenen zwölf Monate. Das Feld `sum(Revenue)` wird dem Diagramm hinzugefügt, um die Differenz zwischen dem Umsatz und der Umsatzsumme der vergangenen zwölf Monate anzuzeigen.
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/windowSum.png)