Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Fonctions de calcul du tableau
Lorsque vous analysez des données dans une représentation visuelle spécifique, vous pouvez appliquer des calculs de tableaux au jeu de données actuel pour découvrir comment les dimensions influencent les mesures ou comment elles s’influencent entre elles. Les *données visualisées* correspondent à votre ensemble de résultats basé sur votre jeu de données actuel, avec l'application de tous les filtres, sélections de champs et personnalisations. Pour voir exactement cet ensemble de résultats, vous pouvez exporter votre représentation visuelle dans un fichier. La *fonction de calcul de tableau* effectue les opérations sur les données pour révéler les relations entre les champs.
Dans cette section, vous trouverez une liste des fonctions disponibles dans les calculs de table que vous pouvez exécuter sur des données visualisées dans Amazon Quick.
Pour consulter la liste des fonctions triées par catégorie, avec de brèves définitions, voir [Fonctions par catégorie](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
La fonction `difference` calcule la différence entre une mesure basée sur un ensemble de partitions et de tris et une mesure basée sur un autre.
La fonction `difference` est prise en charge pour fonctionner avec des analyses basées sur des jeux de données SPICE et de requêtes directes.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
difference
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index,
,[ partition field, ... ]
)
```
## Arguments
*mesure*
Une mesure regroupée pour laquelle vous souhaitez voir la différence.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de recherche*
L'index de recherche peut être positif ou négatif, désignant une ligne suivante dans le tri (valeur positive) ou une ligne précédente dans le tri (valeur négative). L'index de recherche peut être 1–2,147,483,647. Pour les moteurs MySQL, MariaDB et Aurora avec une compatibilité MySQL, l'index de recherche est limité à 1.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule la différence entre des `sum({Billed Amount})`, triés par ordre croissant `Customer Region`, par rapport à la ligne suivante, avec partition selon `Service Line`.
```
difference(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1,
[{Service Line}]
)
```
L'exemple suivant calcule la différence entre `Billed Amount` et la ligne suivante, avec partition selon (`[{Customer Region}]`). Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
difference(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1
)
```
Les mises en surbrillance en rouge montrent comment chaque montant est additionné (a\$1b = c) pour afficher la différence entre les montants a et c.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/differenceCalc.png)
# distinctCountOver
La fonction `distinctCountOver` calcule le nombre distinct d'opérandes partitionnés par les attributs spécifiés dans un niveau donné. Les niveaux pris en charge sont `PRE_FILTER` et `PRE_AGG`. L'opérande doit être désagrégé.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
distinctCountOver
(
measure or dimension field
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*champ mesure ou dimension*
Mesure ou dimension pour laquelle vous souhaitez effectuer le calcul, par exemple `{Sales Amt}`. Les valeurs valides sont `PRE_FILTER` et `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
Lorsqu'elle est vide, la valeur par défaut est `POST_AGG_FILTER`. `POST_AGG_FILTER` n'est pas un niveau valide pour cette opération et, le cas échéant, un message d'erreur s'affichera. Pour plus d'informations, consultez [Utilisation de calculs basés sur les niveaux dans Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant montre le compte distinct de `Sales` partitionné sur `City` et `State` au niveau `PRE_AGG`.
```
distinctCountOver
(
Sales,
[City, State], PRE_AGG
)
```
# lag
La fonction `lag` calcule la valeur de décalage (précédente) pour une mesure en fonction des partitions et tris spécifiés.
`lag` est pris en charge pour fonctionner avec des analyses basées sur des jeux de données SPICE et de requêtes directes.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
lag
(
lag
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index
,[ partition_field, ... ]
)]
)
```
## Arguments
*mesure*
La mesure pour laquelle vous souhaitez obtenir la valeur de décalage. Celle-ci peut inclure un regroupement, par exemple `sum({Sales Amt})`.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de recherche*
L'index de recherche peut être positif ou négatif, désignant une ligne suivante dans le tri (valeur positive) ou une ligne précédente dans le tri (valeur négative). L'index de recherche peut être 1–2,147,483,647. Pour les moteurs MySQL, MariaDB, et Amazon Aurora avec une compatibilité MySQL, l'index de recherche est limité à 1.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule le précédent `sum(sales)`, partitionné par l'état d'origine, par ordre croissant sur `cancellation_code`.
```
lag
(
sum(Sales),
[cancellation_code ASC],
1,
[origin_state_nm]
)
```
L'exemple suivant utilise un champ calculé avec `lag` pour afficher le montant de la ligne précédente, en regard du montant de la ligne actuelle, triés par `Order Date`. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
lag(
sum({Sales}),
[{Order Date} ASC],
1
)
```
La capture d'écran suivante affiche les résultats de l'exemple.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/lagCalc.png)
L'exemple suivant utilise un champ calculé avec `lag` pour afficher le montant de la ligne précédente, en regard du montant de la ligne actuelle, triés par `Order Date` partitionné par `Segment`.
```
lag
(
sum(Sales),
[Order Date ASC],
1, [Segment]
)
```
La capture d'écran suivante affiche les résultats de l'exemple.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/lagCalc2.png)
# lead
La fonction `lead` calcule la valeur principale (suivante) pour une mesure en fonction des partitions et tris spécifiés.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
lead
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index,
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
La mesure pour laquelle vous souhaitez obtenir la valeur principale. Celle-ci peut inclure un regroupement, par exemple `sum({Sales Amt})`.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de recherche*
L'index de recherche peut être positif ou négatif, désignant une ligne suivante dans le tri (valeur positive) ou une ligne précédente dans le tri (valeur négative). L'index de recherche peut être 1–2,147,483,647. Pour les moteurs MySQL, MariaDB, et Amazon Aurora avec une compatibilité MySQL, l'index de recherche est limité à 1.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule le prochain `sum(sales)`, partitionné par l'état d'origine, par ordre croissant sur `cancellation_code`.
```
lead
(
sum(sales),
[cancellation_code ASC],
1,
[origin_state_nm]
)
```
L'exemple suivant utilise un champ calculé avec valeur principale pour afficher le montant de la ligne suivante, en regard du montant de la ligne actuelle, triés par `Customer Segment`. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
lead(
sum({Billed Amount}),
[{Customer Segment} ASC],
1
)
```
La capture d'écran suivante affiche les résultats de l'exemple.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/leadCalc.png)
# percentDifference
La fonction `percentDifference` calcule la différence de pourcentage entre la valeur actuelle et une valeur de comparaison, en fonction des partitions, des tris et de l'index de recherche.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
percentDifference
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup index
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Une mesure regroupée pour laquelle vous souhaitez voir la différence de pourcentage.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de recherche*
L'index de recherche peut être positif ou négatif, désignant une ligne suivante dans le tri (valeur positive) ou une ligne précédente dans le tri (valeur négative). L'index de recherche peut être 1–2,147,483,647. Pour les moteurs MySQL, MariaDB et Aurora avec une compatibilité MySQL, l'index de recherche est limité à 1.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule le pourcentage de différence entre le `sum(Sales)` pour le `State` actuel et le précédent, triés par `Sales`.
```
percentDifference
(
sum(amount),
[sum(amount) ASC],
-1,
[State]
)
```
L'exemple suivant calcule le pourcentage qu'un `Billed Amount` spécifique est par rapport à un autre `Billed Amount`, triés par (`[{Customer Region} ASC]`). Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
percentDifference
(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1
)
```
La capture d'écran suivante affiche les résultats de l'exemple. Les lettres rouges montrent que le `Billed Amount` total pour le `Customer Region` **APAC** est de 24 % inférieur au montant pour la région **EMEA**.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/percentDifference.png)
# avgOver
La fonction `avgOver` calcule la moyenne d'une mesure partitionnée par une liste de dimensions.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
avgOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
L'exemple suivant montre la moyenne de `Billed Amount` sur `Customer Region`. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
avgOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
La capture d'écran suivante affiche les résultats de l'exemple. Avec l'ajout de `Service Line`, le montant total facturé pour chaque est affiché et la moyenne de ces trois valeurs apparaît dans le champ calculé.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/avgOver.png)
## Arguments
*mesure*
Mesure pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant montre la moyenne de `sum(Sales)` partitionnée sur `City` et `State`.
```
avgOver
(
sum(Sales),
[City, State]
)
```
# countOver
La fonction `countOver` calcule le nombre d'une dimension ou mesure partitionné par une liste de dimensions.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
countOver
(
measure or dimension field
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*champ mesure ou dimension*
Mesure ou dimension pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant montre le compte de `Sales` partitionné sur `City` et `State`.
```
countOver
(
Sales,
[City, State]
)
```
L'exemple suivant montre le compte de `{County}` partitionné sur `City` et `State`.
```
countOver
(
{County},
[City, State]
)
```
L'exemple suivant montre le compte de `Billed Amount` sur `Customer Region`. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
countOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
La capture d'écran suivante affiche les résultats de l'exemple. Étant donné qu'il n'y a pas d'autres champs impliqués, le compte est de un pour chaque région.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/countOver1.png)
Si vous ajoutez des champs supplémentaires, le compte change. Dans la capture d'écran suivante, nous additionnons `Customer Segment` et `Service Line`. Chacun de ces champs contient trois valeurs uniques. Avec 3 segments, 3 gammes de services et 3 régions, le champ calculé affiche 9.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/countOver2.png)
Si vous ajoutez les deux autres champs dans les champs de partitionnement du champ calculé, `countOver( sum({Billed Amount}), [{Customer Region}, {Customer Segment}, {Service Line}]`, puis le décompte est à nouveau 1 pour chaque ligne.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/countOver.png)
# maxOver
La fonction `maxOver` calcule le maximum d'une mesure ou date partitionné par une liste de dimensions.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
maxOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*mesure*
Mesure pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant calcule le maximum de `sum(Sales)`, partitionné selon `City` et `State`.
```
maxOver
(
sum(Sales),
[City, State]
)
```
L'exemple suivant montre le maximum de `Billed Amount` sur `Customer Region`. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
maxOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
La capture d'écran suivante affiche les résultats de l'exemple. Avec l'ajout de `Service Line`, le montant total facturé pour chaque est affiché et le maximum de ces trois valeurs apparaît dans le champ calculé.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/maxOver.png)
# minOver
la fonction `minOver` calcule le minimum d'une mesure ou date partitionné par une liste de dimensions.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
minOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*mesure*
Mesure pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant calcule le minimum de `sum(Sales)`, partitionné selon `City` et `State`.
```
minOver
(
sum(Sales),
[City, State]
)
```
L'exemple suivant montre le minimum de `Billed Amount` sur `Customer Region`. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
minOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
La capture d'écran suivante affiche les résultats de l'exemple. Avec l'ajout de `Service Line`, le montant total facturé pour chaque est affiché et le minimum de ces trois valeurs apparaît dans le champ calculé.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/minOver.png)
# percentileOver
La fonction `percentileOver` calcule le *énième* percentile d'une mesure partitionnée par une liste de dimensions. Deux types de `percentileOver` calcul sont disponibles dans Quick :
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html) utilise l'interpolation linéaire pour déterminer le résultat.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html) utilise les valeurs réelles pour déterminer le résultat.
La fonction `percentileOver` est un alias de `percentileDiscOver`.
# percentileContOver
La fonction `percentileContOver` calcule le percentile en fonction des nombres réels contenus dans `measure`. Elle utilise le regroupement et le tri appliqués dans les zones de champs. Le résultat est partitionné selon la dimension spécifiée au niveau de calcul spécifié.
Utilisez cette fonction pour répondre à la question suivante : Quels sont les points de données réels présents dans ce percentile ? Pour renvoyer la valeur de percentile la plus proche présente dans votre jeu de données, utilisez `percentileDiscOver`. Pour renvoyer une valeur percentile exacte qui n'est peut-être pas présente dans votre jeu de données, utilisez plutôt `percentileContOver`.
## Syntaxe
```
percentileContOver (
measure
, percentile-n
, [partition-by, …]
, calculation-level
)
```
## Arguments
*mesure*
Spécifie une valeur numérique à utiliser pour calculer le percentile. L'argument doit être une mesure ou une métrique. Les valeurs NULL sont ignorées dans le calcul.
*percentile-n*
La valeur du percentile peut être n'importe quelle constante numérique située entre 0 et 100. Une valeur de percentile de 50 calcule la valeur médiane de la mesure.
*partition-by*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules. Chaque champ de la liste est placé dans des accolades \$1 \$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
Spécifie l'emplacement où effectuer le calcul par rapport à l'ordre d'évaluation. Trois niveaux de calcul sont pris en charge :
+ PRE\$1FILTER
+ PRE\$1AGG
+ POST\$1AGG\$1FILTER (par défaut) – Pour utiliser ce niveau de calcul, spécifiez une agrégation sur `measure`, par exemple `sum(measure)`.
PRE\$1FILTER et PRE\$1AGG sont appliqués avant que l'agrégation ne se produise dans une visualisation. Pour ces deux niveaux de calcul, il est impossible de spécifier une agrégation sur `measure` dans l'expression du champ calculé. Pour en savoir plus sur les niveaux de calcul et les circonstances dans lesquelles ils s'appliquent, consultez [Ordre d'évaluation dans Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/order-of-evaluation-quicksight.html) et [Utilisation de calculs adaptés aux niveaux dans](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html) Quick.
## Renvoie
Le résultat de la fonction est un nombre.
## Exemple de percentileContOver
L'exemple suivant permet d'expliquer comment percentileContOver cela fonctionne.
**Example Comparaison des niveaux de calcul pour la médiane**
L'exemple suivant illustre la médiane d'une dimension (catégorie) en utilisant différents niveaux de calcul avec la fonction `percentileContOver`. Le percentile est 50. Le jeu de données est filtré par un champ de région. Le code de chaque champ calculé est le suivant :
+ `example = left( category, 1 )` (Un exemple simplifié.)
+ `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
La fonction `percentileDiscOver` calcule le percentile en fonction des nombres réels contenus dans `measure`. Elle utilise le regroupement et le tri appliqués dans les zones de champs. Le résultat est partitionné selon la dimension spécifiée au niveau de calcul spécifié. La fonction `percentileOver` est un alias de `percentileDiscOver`.
Utilisez cette fonction pour répondre à la question suivante : Quels sont les points de données réels présents dans ce percentile ? Pour renvoyer la valeur de percentile la plus proche présente dans votre jeu de données, utilisez `percentileDiscOver`. Pour renvoyer une valeur percentile exacte qui n'est peut-être pas présente dans votre jeu de données, utilisez plutôt `percentileContOver`.
## Syntaxe
```
percentileDiscOver (
measure
, percentile-n
, [partition-by, …]
, calculation-level
)
```
## Arguments
*mesure*
Spécifie une valeur numérique à utiliser pour calculer le percentile. L'argument doit être une mesure ou une métrique. Les valeurs NULL sont ignorées dans le calcul.
*percentile-n*
La valeur du percentile peut être n'importe quelle constante numérique située entre 0 et 100. Une valeur de percentile de 50 calcule la valeur médiane de la mesure.
*partition-by*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules. Chaque champ de la liste est placé dans des accolades \$1 \$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
Spécifie l'emplacement où effectuer le calcul par rapport à l'ordre d'évaluation. Trois niveaux de calcul sont pris en charge :
+ PRE\$1FILTER
+ PRE\$1AGG
+ POST\$1AGG\$1FILTER (par défaut) – Pour utiliser ce niveau de calcul, vous devez spécifier une agrégation sur `measure`, par exemple `sum(measure)`.
PRE\$1FILTER et PRE\$1AGG sont appliqués avant que l'agrégation ne se produise dans une visualisation. Pour ces deux niveaux de calcul, il est impossible de spécifier une agrégation sur `measure` dans l'expression du champ calculé. Pour en savoir plus sur les niveaux de calcul et les circonstances dans lesquelles ils s'appliquent, consultez [Ordre d'évaluation dans Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/order-of-evaluation-quicksight.html) et [Utilisation de calculs adaptés aux niveaux dans](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html) Quick.
## Renvoie
Le résultat de la fonction est un nombre.
## Exemple de percentileDiscOver
L'exemple suivant permet d'expliquer comment percentileDiscOver cela fonctionne.
**Example Comparaison des niveaux de calcul pour la médiane**
L'exemple suivant illustre la médiane d'une dimension (catégorie) en utilisant différents niveaux de calcul avec la fonction `percentileDiscOver`. Le percentile est 50. Le jeu de données est filtré par un champ de région. Le code de chaque champ calculé est le suivant :
+ `example = left( category, 1 )` (Un exemple simplifié.)
+ `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 La médiane**
L'exemple suivant calcule la moyenne (le 50e percentile) de `Sales`, partitionnée selon `City` et `State`.
```
percentileDiscOver
(
Sales,
50,
[City, State]
)
```
L'exemple suivant calcule le 98e percentile de `sum({Billed Amount})`, partitionné selon `Customer Region`. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
percentileDiscOver
(
sum({Billed Amount}),
98,
[{Customer Region}]
)
```
La capture d'écran suivante montre à quoi ressemblent ces deux exemples sur un graphique.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/percentilOver-50-98.png)
# percentOfTotal
La fonction `percentOfTotal` calcule le pourcentage de contribution d'une mesure au total, en fonction des dimensions spécifiées.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
percentOfTotal
(
measure
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Une mesure regroupée pour laquelle vous souhaitez voir le pourcentage par rapport au total. Actuellement, le regroupement `distinct count` n'est pas pris en charge pour `percentOfTotal`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant crée un calcul pour le pourcentage du nombre total de `Sales` avec contribution de chaque `State`.
```
percentOfTotal
(
sum(Sales),
[State]
)
```
L'exemple suivant calcule le pourcentage d'un `Billed Amount` spécifique par rapport au `Billed Amount` total, avec partition par (`[{Service Line} ASC]`). Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
percentOfTotal
(
sum( {Billed Amount} ),
[{Service Line}]
)
```
La capture d'écran suivante affiche les résultats de l'exemple. Les mises en surbrillance en rouge montrent que le champ de partition avec la valeur «`Billing`» possède trois entrées, une pour chaque région. Le montant total facturé pour cette gamme de services est divisé en trois pourcentages, pour un total de 100 %. Les pourcentages sont arrondis et peuvent ne pas toujours donner exactement 100 % une fois cumulés.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/percentOfTotal.png)
# periodOverPeriodDifference
La fonction `periodOverPeriodDifference` calcule la différence d'une mesure sur deux périodes différentes, comme indiqué par la granularité et le décalage de la période. Contrairement au calcul de différence, cette fonction utilise un décalage basé sur la date au lieu d'un décalage de taille fixe. Cela garantit que seules les dates correctes sont comparées, même s'il manque des points de données dans le jeu de données.
## Syntaxe
```
periodOverPeriodDifference(
measure,
date,
period,
offset)
```
## Arguments
*mesure*
Mesure agrégée sur laquelle vous souhaitez effectuer le periodOverPeriod calcul.
*dateTime*
Dimension de date sur laquelle nous calculons Period-Over-Period les calculs.
*point*
(Facultatif) La période de temps sur laquelle vous effectuez le calcul. La granularité de `YEAR` signifie un calcul `YearToDate`, `Quarter` signifie `QuarterToDate` et ainsi de suite. Les granularités valides comprennent `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` et `SECONDS`.
La valeur par défaut est la granularité de la dimension visuelle de la date.
*offset*
(Facultatif) Le décalage peut être un entier positif ou négatif qui représente la période précédente (spécifiée par période) à laquelle vous désirez effectuer la comparaison. Par exemple, la période d'un trimestre présentant le décalage 1 signifie une comparaison avec le trimestre précédent.
La valeur par défaut est 1.
## Exemple
L'exemple suivant utilise un champ calculé `PeriodOverPeriod` pour afficher la différence du montant des ventes du jour précédent
```
periodOverPeriodDifference(sum(Sales), {Order Date})
```
![\[Il s'agit d'une image du retour de l'exemple de calcul.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/MonthOverMonthDifference.png)
L'exemple suivant utilise un champ calculé `PeriodOverPeriod` pour afficher la différence du montant des ventes des 2 mois précédents. L'exemple ci-dessous compare les ventes de `Mar2020` avec `Jan2020`.
```
periodOverPeriodDifference(sum(Sales),{Order Date}, MONTH, 1)
```
![\[Il s'agit d'une image du retour de l'exemple de calcul.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/MonthOverMonthDifference2.png)
# periodOverPeriodLastValue
La fonction `periodOverPeriodLastValue` calcule la dernière valeur (précédente) d'une mesure par rapport à la période précédente, comme spécifiée par la granularité et le décalage de la période. Cette fonction utilise un décalage basé sur la date au lieu d'un décalage de taille fixe. Cela garantit que seules les dates correctes sont comparées, même s'il manque des points de données dans le jeu de données.
## Syntaxe
```
periodOverPeriodLastValue(
measure,
date,
period,
offset)
```
## Arguments
*mesure*
Une mesure regroupée pour laquelle vous souhaitez voir la différence.
*date*
Dimension de date sur laquelle vous calculez periodOverPeriod les calculs.
*point*
(Facultatif) La période de temps sur laquelle vous effectuez le calcul. La granularité de `YEAR` signifie un calcul `YearToDate`, `Quarter` signifie `QuarterToDate` et ainsi de suite. Les granularités valides comprennent `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` et `SECONDS`.
Cet argument correspond par défaut à la granularité de l'agrégation visuelle
*offset*
(Facultatif) Le décalage peut être un entier positif ou négatif qui représente la période précédente (spécifiée par période) à laquelle vous désirez effectuer la comparaison. Par exemple, la période d'un trimestre présentant le décalage 1 signifie une comparaison avec le trimestre précédent.
La valeur par défaut de cet argument est 1.
## Exemple
L'exemple suivant calcule la valeur mensuelle des ventes avec la granularité des dimensions visuelles ainsi qu'un décalage par défaut de 1.
```
periodOverPeriodLastValue(sum(Sales), {Order Date})
```
L'exemple suivant calcule la valeur mensuelle des ventes avec une granularité fixe de `MONTH` et un décalage fixe de 1.
```
periodOverPeriodLastValue(sum(Sales), {Order Date},MONTH, 1)
```
![\[Il s'agit d'une image du retour de l'exemple de calcul.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/MonthOverMonthLastValue.png)
# periodOverPeriodPercentDifference
La fonction `periodOverPeriodPercentDifference` calcule la différence en pourcentage d'une mesure sur deux périodes différentes, comme indiqué par la granularité et le décalage de la période. Contrairement à percentDifference, cette fonction utilise un décalage basé sur la date au lieu d'un décalage de taille fixe. Cela garantit que seules les dates correctes sont comparées, même s'il manque des points de données dans le jeu de données.
## Syntaxe
```
periodOverPeriodPercentDifference(
measure,
date,
period,
offset)
```
## Arguments
*mesure*
Une mesure regroupée pour laquelle vous souhaitez voir la différence.
*date*
Dimension de date sur laquelle vous calculez periodOverPeriod les calculs.
*point*
(Facultatif) La période de temps sur laquelle vous effectuez le calcul. La granularité de `YEAR` signifie un calcul `YearToDate`, `Quarter` signifie `QuarterToDate` et ainsi de suite. Les granularités valides comprennent `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` et `SECONDS`.
Cet argument correspond par défaut à la granularité de l'agrégation visuelle
*offset*
(Facultatif) Le décalage peut être un entier positif ou négatif qui représente la période précédente (spécifiée par période) à laquelle vous désirez effectuer la comparaison. Par exemple, la période d'un trimestre présentant le décalage 1 signifie une comparaison avec le trimestre précédent.
La valeur par défaut de cet argument est 1.
## Exemple
L'exemple suivant calcule la différence mensuelle en pourcentage avec la granularité des dimensions visuelles ainsi qu'un décalage par défaut de 1.
```
periodOverPeriodPercentDifference(sum(Sales),{Order Date})
```
L'exemple suivant calcule la différence mensuelle en pourcentage des ventes avec une granularité fixe `MONTH` ainsi qu'un décalage fixe de 1.
```
periodOverPeriodPercentDifference(sum(Sales), {Order Date}, MONTH, 1)
```
![\[Il s'agit d'une image du retour de l'exemple de calcul.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/MonthOverMonthPercentDifference.png)
# periodToDateAvgOverTime
La fonction calcule `periodToDateAvgOverTime` la moyenne d'une mesure pour une granularité temporelle donnée (par exemple, un quart) jusqu'à un certain point dans le temps.
## Syntaxe
```
periodToDateAvgOverTime(
measure,
dateTime,
period)
```
## Arguments
*mesure*
Mesure regroupée pour laquelle vous souhaitez effectuer le calcul
*dateTime*
Dimension de date sur laquelle vous calculez PeriodOverTime les calculs.
*point*
(Facultatif) La période de temps sur laquelle vous effectuez le calcul. La granularité de `YEAR` signifie un calcul `YearToDate`, `Quarter` signifie `QuarterToDate` et ainsi de suite. Les granularités valides comprennent `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` et `SECONDS`.
La valeur par défaut est la granularité de la dimension de date du visuel.
## Exemple
La fonction suivante calcule le montant moyen du tarif d'un mois à l'autre.
```
periodToDateAvgOverTime(sum({fare_amount}), pickupDatetime, MONTH)
```
![\[Voici une image qui présente les résultats du calcul de l'exemple avec des illustrations.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/PTDAvgOverTimeResults.png)
# periodToDateCountOverTime
La fonction `periodToDateCountOverTime` calcule le nombre d'une dimension ou d'une mesure pour une granularité temporelle donnée (par exemple, un quart) jusqu'à un certain point dans le temps.
## Syntaxe
```
periodToDateCountOverTime(
measure,
dateTime,
period)
```
## Arguments
*mesure*
Mesure regroupée pour laquelle vous souhaitez effectuer le calcul
*dateTime*
Dimension de date sur laquelle vous calculez PeriodOverTime les calculs.
*point*
(Facultatif) La période de temps sur laquelle vous effectuez le calcul. La granularité de `YEAR` signifie un calcul `YearToDate`, `Quarter` signifie `QuarterToDate` et ainsi de suite. Les granularités valides comprennent `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` et `SECONDS`.
La valeur par défaut est la granularité de la dimension de date du visuel.
## Exemple
L'exemple suivant calcule le nombre de fournisseurs mois après mois.
```
periodToDateCountOverTime(count(vendorid), pickupDatetime, MONTH)
```
![\[Voici une image qui présente les résultats du calcul de l'exemple avec des illustrations.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/PTDCountOverTimeResults.png)
# periodToDateMaxOverTime
La fonction `periodToDateMaxOverTime` calcule le maximum d'une mesure pour une granularité temporelle donnée (par exemple, un quart) jusqu'à un certain point dans le temps.
## Syntaxe
```
periodToDateMaxOverTime(
measure,
dateTime,
period)
```
## Arguments
*mesure*
Mesure regroupée pour laquelle vous souhaitez effectuer le calcul
*dateTime*
Dimension de date sur laquelle vous calculez PeriodOverTime les calculs.
*point*
(Facultatif) La période de temps sur laquelle vous effectuez le calcul. La granularité de `YEAR` signifie un calcul `YearToDate`, `Quarter` signifie `QuarterToDate` et ainsi de suite. Les granularités valides comprennent `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` et `SECONDS`.
La valeur par défaut est la granularité de la dimension de date du visuel.
## Exemple
L'exemple suivant calcule le montant maximum du tarif d'un mois à l'autre.
```
periodToDatemaxOverTime(max({fare_amount}), pickupDatetime, MONTH)
```
![\[Voici une image qui présente les résultats du calcul de l'exemple avec des illustrations.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/PTDMaxOverTimeResults.png)
# periodToDateMinOverTime
La fonction `periodToDateMinOverTime` calcule le minimum d'une mesure pour une granularité temporelle donnée (par exemple, un quart) jusqu'à un certain point dans le temps.
## Syntaxe
```
periodToDateMinOverTime(
measure,
dateTime,
period)
```
## Arguments
*mesure*
Mesure regroupée pour laquelle vous souhaitez effectuer le calcul
*dateTime*
Dimension de date sur laquelle vous calculez PeriodOverTime les calculs.
*point*
(Facultatif) La période de temps sur laquelle vous effectuez le calcul. La granularité de `YEAR` signifie un calcul `YearToDate`, `Quarter` signifie `QuarterToDate` et ainsi de suite. Les granularités valides comprennent `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` et `SECONDS`.
La valeur par défaut est la granularité de la dimension de date du visuel.
## Exemple
L'exemple suivant calcule le montant du tarif minimum d'un mois à l'autre.
```
periodToDateMinOverTime(min({fare_amount}), pickupDatetime, MONTH)
```
![\[Voici une image qui présente les résultats du calcul de l'exemple avec des illustrations.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/PTDMinOverTimeResults.png)
# periodToDateSumOverTime
La fonction `periodToDateSumOverTime` calcule la somme d'une mesure pour une granularité temporelle donnée (par exemple, un quart) jusqu'à un certain point dans le temps.
## Syntaxe
```
periodToDateSumOverTime(
measure,
dateTime,
period)
```
## Arguments
*mesure*
Mesure regroupée pour laquelle vous souhaitez effectuer le calcul
*dateTime*
Dimension de date sur laquelle vous calculez PeriodOverTime les calculs.
*point*
(Facultatif) La période de temps sur laquelle vous effectuez le calcul. La granularité de `YEAR` signifie un calcul `YearToDate`, `Quarter` signifie `QuarterToDate` et ainsi de suite. Les granularités valides comprennent `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` et `SECONDS`.
La valeur par défaut est la granularité de la dimension de date du visuel.
## Exemple
La fonction suivante donne le montant total du tarif d'un mois à l'autre.
```
periodToDateSumOverTime(sum({fare_amount}), pickupDatetime, MONTH)
```
![\[Voici une image qui présente les résultats du calcul de l'exemple avec des illustrations.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/PTDSumOverTime-example-results.png)
# stdevOver
la fonction `stdevOver` calcule l'écart type de la mesure spécifiée, partitionné par l'attribut ou les attributs choisis, sur la base d'un échantillon.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
stdevOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*mesure*
Mesure pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (par défaut) les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant calcule l'écart type de `sum(Sales)`, partitionné par `City` et `State`, sur la base d'un échantillon.
```
stdevOver
(
sum(Sales),
[City, State]
)
```
L'exemple suivant calcule l'écart type de `Billed Amount` plus de `Customer Region`, sur la base d'un échantillon. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
stdevOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# stdevpOver
La fonction `stdevpOver` calcule l'écart type de la mesure spécifiée, partitionné par l'attribut ou les attributs choisis, en fonction d'une population biaisée.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
stdevpOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*mesure*
Mesure pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (par défaut) les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant calcule l'écart type de `sum(Sales)`, partitionnés par `City` et `State`, sur la base d'un remplissage biaisé.
```
stdevpOver
(
sum(Sales),
[City, State]
)
```
L'exemple suivant calcule l'écart type de `Billed Amount` sur `Customer Region`, sur la base d'un remplissage biaisé. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
stdevpOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# varOver
La fonction `varOver` calcule la variance de la mesure spécifiée, partitionnée par l'attribut ou les attributs choisis, sur la base d'un échantillon.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
varOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*mesure*
Mesure pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant calcule la variance de `sum(Sales)`, partitionnée par `City` et `State`, sur la base d' un échantillon.
```
varOver
(
sum(Sales),
[City, State]
)
```
L'exemple suivant calcule la variance de `Billed Amount` sur `Customer Region`, sur la base d' un échantillon. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
varOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# varpOver
La fonction `varpOver` calcule la variance de la mesure spécifiée, partitionnée par l'attribut ou les attributs choisis, sur la base d'un remplissage biaisé.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
varpOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*mesure*
Mesure pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant calcule la variance de `sum(Sales)`, partitionnée par `City` et `State`, sur la base d'un remplissage biaisé.
```
varpOver
(
sum(Sales),
[City, State]
)
```
L'exemple suivant calcule la variance de `Billed Amount` sur `Customer Region`, sur la base d'un remplissage biaisé. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
varpOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# sumOver
La fonction `sumOver` calcule la somme d'une mesure partitionnée par une liste de dimensions.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
sumOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments
*mesure*
Mesure pour laquelle vous souhaitez effectuer le calcul, par exemple `sum({Sales Amt})`. Utilisez un regroupement si le niveau de calcul est défini sur `NULL` ou `POST_AGG_FILTER`. N'utilisez pas de regroupement si le niveau de calcul est défini sur `PRE_FILTER` ou `PRE_AGG`.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (par défaut) les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant calcule la somme de `sum(Sales)`, partitionnée selon `City` et `State`.
```
sumOver
(
sum(Sales),
[City, State]
)
```
L'exemple suivant calcule la somme de `Billed Amount` sur `Customer Region`. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
sumOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
La capture d'écran suivante affiche les résultats de l'exemple. Avec l'ajout de `Customer Segment`, le montant total facturé pour chaque est additionné pour le `Customer Region` et s'affiche dans le champ calculé.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/sumOver.png)
# denseRank
La fonction `denseRank` calcule le rang d'une mesure ou une dimension en comparaison avec les partitions spécifiées. Il ne comptabilise chaque élément qu'une seule fois, sans tenir compte des doublons, et attribue un classement « sans trous » afin que les valeurs en double partagent le même rang.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
denseRank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments
*champ pour l'ordre de tri*
Un ou plusieurs champs regroupés, des mesures ou des dimensions ou les deux, selon lesquels vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant classe densément `max(Sales)`, selon un ordre de tri décroissant, par `State` et `City`. Toutes les villes avec les mêmes `max(Sales)` reçoivent le même classement et la ville suivante est classée au rang suivant. Par exemple, si trois villes partagent le même classement, la quatrième ville est classée comme deuxième.
```
denseRank
(
[max(Sales) DESC],
[State, City]
)
```
L'exemple suivant classe densément `max(Sales)`, selon un ordre de tri décroissant, par `State`. Tous les états avec les mêmes `max(Sales)` reçoivent le même classement et l'état suivant est classé au rang suivant. Par exemple, si trois états partagent le même classement, le quatrième état est classé comme deuxième.
```
denseRank
(
[max(Sales) DESC],
[State]
)
```
# rank
La fonction `rank` calcule le rang d'une mesure ou une dimension en comparaison avec les partitions spécifiées. Il comptabilise chaque élément, même des doublons, une fois et attribue un classement « avec trous » pour compenser les valeurs en double.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
rank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions regroupées selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant classe `max(Sales)`, selon un ordre de tri décroissant, par `State` et `City`, dans le `State` de **WA**. Toutes les villes avec les mêmes `max(Sales)` reçoivent le même classement, mais le rang suivant inclut le nombre de tous les rangs existant précédemment. Par exemple, si trois villes partagent le même classement, la quatrième ville est classée comme quatrième.
```
rank
(
[max(Sales) DESC],
[State, City]
)
```
L'exemple suivant classe `max(Sales)`, selon un ordre de tri croissant, par `State`. Tous les états avec les mêmes `max(Sales)` reçoivent le même classement, mais le rang suivant inclut le nombre de tous les rangs existant précédemment. Par exemple, si trois états partagent le même classement, le quatrième état est classé comme quatrième.
```
rank
(
[max(Sales) ASC],
[State]
)
```
L'exemple suivant classe `Customer Region` selon le `Billed Amount` total. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
rank(
[sum({Billed Amount}) DESC]
)
```
La capture d'écran suivante affiche les résultats de l'exemple, ainsi que le `Billed Amount` total, afin que vous puissiez voir le classement de chaque région.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/rankCalc.png)
# percentileRank
La fonction `percentileRank` calcule le rang en percentile d'une mesure ou une dimension en comparaison avec les partitions spécifiées. La valeur du classement percentile (*x*) indique que l'élément actuel est supérieur au *x* % des valeurs de la partition spécifiée. La plage de valeurs du rang en percentile s'étend de 0 (inclus) à 100 (exclu).
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
percentileRank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ {partition_field}, ... ]
)
```
## Arguments
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions regroupées selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*niveau de calcul*
(Facultatif) Spécifie le niveau de calcul à utiliser :
+ **`PRE_FILTER`** – Les calculs de pré-filtre sont effectués avant les filtres de jeu de données.
+ **`PRE_AGG`** – Les calculs de pré-regroupement sont effectués avant d'appliquer les regroupements et les filtres *N* premiers/derniers aux représentations visuelles.
+ **`POST_AGG_FILTER`** – (Par défaut) Les calculs de tableau sont effectués lorsque les représentations visuelles s'affichent.
La valeur par défaut est `POST_AGG_FILTER` lorsqu’elle est vide. Pour plus d'informations, consultez la section [Utilisation de calculs basés sur les niveaux dans Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemple
L'exemple suivant effectue un classement par percentile de `max(Sales)` dans l'ordre décroissant par `State`.
```
percentileRank
(
[max(Sales) DESC],
[State]
)
```
L'exemple suivant effectue un classement par percentile de `Customer Region` par `Billed Amount` total. Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
percentileRank(
[sum({Billed Amount}) DESC],
[{Customer Region}]
)
```
La capture d'écran suivante affiche les résultats de l'exemple, ainsi que le `Billed Amount` total, afin que vous puissiez voir la comparaison des différentes régions.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/percentileRank.png)
# runningAvg
La fonction `runningAvg` calcule une moyenne pour une mesure basée sur les dimensions et les ordres de tri spécifiés.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
runningAvg
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Une mesure agrégée pour laquelle vous souhaitez générer la moyenne.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule une moyenne de `sum(Sales)`, triée par `Sales`, partitionnée selon `City` et `State`.
```
runningAvg
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'exemple suivant calcule une moyenne de `Billed Amount`, triée par mois (`[truncDate("MM",Date) ASC]`). Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
runningAvg
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningCount
La fonction `runningCount` calcule un nombre pour une mesure ou une dimension basée sur les dimensions et les ordres de tri spécifiés.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
runningCount
(
measure_or_dimension
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments
*mesure ou dimension*
Une mesure ou une dimension regroupée pour laquelle vous souhaitez générer le nombre.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule un nombre de `sum(Sales)`, trié par `Sales`, partitionné selon `City` et `State`.
```
runningCount
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'exemple suivant calcule un nombre de `Billed Amount`, trié par mois (`[truncDate("MM",Date) ASC]`). Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
runningCount
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningMax
La fonction `runningMax` calcule un maximum pour une mesure basée sur les dimensions et les ordres de tri spécifiés.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
runningMax
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Une mesure agrégée pour laquelle vous souhaitez générer le maximum.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule un maximum de `sum(Sales)`, trié par `Sales`, partitionné selon `City` et `State`.
```
runningMax
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'exemple suivant calcule un maximum de `Billed Amount`, trié par mois (`[truncDate("MM",Date) ASC]`). Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
runningMax
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningMin
La fonction `runningMin` calcule un minimum pour une mesure basée sur les dimensions et les ordres de tri spécifiés.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
runningMin
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Une mesure regroupée pour laquelle vous souhaitez générer le minimum.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule un minimum de `sum(Sales)`, trié par `Sales`, partitionné selon `City` et `State`.
```
runningMin
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'exemple suivant calcule un minimum de `Billed Amount`, trié par mois (`[truncDate("MM",Date) ASC]`). Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
runningMin
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningSum
La fonction `runningSum` calcule une somme pour une mesure basée sur les dimensions et les ordres de tri spécifiés.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
runningSum
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Une mesure agrégée pour laquelle vous souhaitez générer la somme.
*champ pour l'ordre de tri*
Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule une somme de `sum(Sales)`, triée par `Sales`, partitionnée selon `City` et `State`.
```
runningSum
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'exemple suivant calcule une somme de `Billed Amount`, triée par mois (`[truncDate("MM",Date) ASC]`). Les champs du calcul de tableau se trouvent dans les sélecteurs de champs de la représentation visuelle.
```
runningSum
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
La capture d'écran suivante affiche les résultats de l'exemple. Les étiquettes rouges montrent comment chaque montant est additionné (`a + b = c`) au montant suivant, ce qui se traduit par un nouveau total.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/runningSum.png)
# firstValue
La fonction `firstValue` calcule la première valeur de la mesure ou de la dimension agrégée, partitionnée et triée selon les attributs spécifiés.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
firstValue
(
aggregated measure or dimension,
[ sort_attribute ASC_or_DESC, ... ],
[ partition_by_attribute, ... ]
)
```
## Arguments
*mesure ou dimension agrégée*
Une mesure ou une dimension regroupée dont vous voulez voir la première valeur.
*trier attribut*
Un ou plusieurs champs regroupés, des mesures ou des dimensions ou les deux, selon lesquels vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*partition par attribut*
(Facultatif) Une ou plusieurs mesures ou dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule le premier `Destination Airport`, trié par `Flight Date`, partitionné par `Flight Date` en ordre croissant ainsi que `Origin Airport`.
```
firstValue(
{Destination Airport}
[{Flight Date} ASC],
[
{Origin Airport},
{Flight Date}
]
)
```
# lastValue
La fonction `lastValue` calcule la dernière valeur de la mesure regroupée ou de la dimension partitionnée et triée selon les attributs spécifiés.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
lastValue
(
aggregated measure or dimension,
[ sort_attribute ASC_or_DESC, ... ],
[ partition_by_attribute, ... ]
)
```
## Arguments
*mesure ou dimension agrégée*
Une mesure ou une dimension regroupée dont vous voulez voir la dernière valeur.
*trier attribut*
Un ou plusieurs champs regroupés, des mesures ou des dimensions ou les deux, selon lesquels vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (`ASC`) ou décroissant (`DESC`).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*partition par attribut*
(Facultatif) Une ou plusieurs mesures ou dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule la dernière valeur pour `Destination Airport`. Ce calcul est trié en fonction de la valeur `Flight Date` et partitionné en fonction de la valeur `Flight Date` triée par ordre croissant ainsi que de la valeur `Origin Airport`.
```
lastValue(
[{Destination Airport}],
[{Flight Date} ASC],
[
{Origin Airport},
truncDate('DAY', {Flight Date})
]
)
```
# windowAvg
La fonction `windowAvg` calcule la moyenne de la mesure regroupée dans une fenêtre personnalisée qui est divisée et triée par les attributs spécifiés. En règle générale, vous utilisez les fonctions de fenêtrage personnalisé sur une série chronologique, dans laquelle votre représentation visuelle affiche une métrique et un champ de date. Par exemple, vous pouvez utiliser `windowAvg` pour calculer une moyenne mobile, qui est souvent utilisée pour lisser le bruit dans un graphique en aires.
Les fonctions de fenêtrage ne sont pas prises en charge pour les versions MySQL antérieures à 8 et pour les versions MariaDB antérieures à 10.2.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
windowAvg
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Les métriques regroupées pour lesquelles vous souhaitez obtenir la moyenne, par exemple `sum({Revenue})`.
*trier attribut*
Un ou plusieurs champs regroupés, des mesures ou des dimensions ou les deux, selon lesquels vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1 \$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de début*
L'index de début est un entier positif indiquant *n* lignes au-dessus de la ligne actuelle. L'index de début comptabilise les points de données disponibles au-dessus de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*index de fin*
L'index de fin est un entier positif indiquant *n* lignes en dessous de la ligne actuelle. L'index de fin comptabilise les points de données disponibles en dessous de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule la moyenne mobile de `sum(Revenue)`, partitionnée selon `SaleDate`. Le calcul comprend trois lignes au-dessus et deux lignes en dessous de la ligne actuelle.
```
windowAvg
(
sum(Revenue),
[SaleDate ASC],
3,
2
)
```
La capture d'écran suivante affiche les résultats de cet exemple de moyenne mobile. Le champ somme (Revenu) est ajouté au graphique pour montrer la différence entre le revenu et la moyenne mobile des revenus.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/windowAvg.png)
# windowCount
La fonction `windowCount` calcule le nombre de mesures ou de dimensions regroupées dans une fenêtre personnalisée qui est divisée et triée par les attributs spécifiés. En règle générale, vous utilisez les fonctions de fenêtrage personnalisé sur une série chronologique, dans laquelle votre représentation visuelle affiche une métrique et un champ de date.
Les fonctions de fenêtrage ne sont pas prises en charge pour les versions MySQL antérieures à 8 et pour les versions MariaDB antérieures à 10.2.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
windowCount
(
measure_or_dimension
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments
*mesure ou dimension*
Les métriques regroupées pour lesquelles vous souhaitez obtenir la moyenne, par exemple `sum({Revenue})`.
*trier attribut*
Un ou plusieurs champs regroupés, des mesures ou des dimensions ou les deux, selon lesquels vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de début*
L'index de début est un entier positif indiquant *n* lignes au-dessus de la ligne actuelle. L'index de début comptabilise les points de données disponibles au-dessus de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*index de fin*
L'index de fin est un entier positif indiquant *n* lignes en dessous de la ligne actuelle. L'index de fin comptabilise les points de données disponibles en dessous de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule le nombre mobile de `sum(Revenue)`, partitionné selon `SaleDate`. Le calcul comprend trois lignes au-dessus et deux lignes en dessous de la ligne actuelle.
```
windowCount
(
sum(Revenue),
[SaleDate ASC],
3,
2
)
```
# windowMax
La fonction `windowMax` calcule le maximum de la mesure regroupée dans une fenêtre personnalisée qui est divisée et triée par les attributs spécifiés. En règle générale, vous utilisez les fonctions de fenêtrage personnalisé sur une série chronologique, dans laquelle votre représentation visuelle affiche une métrique et un champ de date. Vous pouvez utiliser `windowMax` pour vous aider à identifier le maximum de la métrique sur une période de temps.
Les fonctions de fenêtrage ne sont pas prises en charge pour les versions MySQL antérieures à 8 et pour les versions MariaDB antérieures à 10.2.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
windowMax
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Les métriques regroupées pour lesquelles vous souhaitez obtenir la moyenne, par exemple `sum({Revenue})`.
*trier attribut*
Un ou plusieurs champs regroupés, des mesures ou des dimensions ou les deux, selon lesquels vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de début*
L'index de début est un entier positif indiquant *n* lignes au-dessus de la ligne actuelle. L'index de début comptabilise les points de données disponibles au-dessus de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*index de fin*
L'index de fin est un entier positif indiquant *n* lignes en dessous de la ligne actuelle. L'index de fin comptabilise les points de données disponibles en dessous de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule le maximum sur 12 mois de `sum(Revenue)`, partitionné par `SaleDate`. Le calcul comprend 12 lignes au-dessus et 0 lignes en dessous de la ligne actuelle.
```
windowMax
(
sum(Revenue),
[SaleDate ASC],
12,
0
)
```
La capture d'écran suivante affiche les résultats de cet exemple sur 12 mois. Le champ somme (Revenu) est ajouté au graphique pour montrer la différence entre le revenu et les revenus maximum sur la période de 12 mois.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/windowMax.png)
# windowMin
La fonction `windowMin` calcule le minimum de la mesure regroupée dans une fenêtre personnalisée qui est divisée et triée par les attributs spécifiés. En règle générale, vous utilisez les fonctions de fenêtrage personnalisé sur une série chronologique, dans laquelle votre représentation visuelle affiche une métrique et un champ de date. Vous pouvez utiliser `windowMin` pour vous aider à identifier le minimum de la métrique sur une période de temps.
Les fonctions de fenêtrage ne sont pas prises en charge pour les versions MySQL antérieures à 8 et pour les versions MariaDB antérieures à 10.2.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
windowMin
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Les métriques regroupées pour lesquelles vous souhaitez obtenir la moyenne, par exemple `sum({Revenue})`.
*trier attribut*
Un ou plusieurs champs regroupés, des mesures ou des dimensions ou les deux, selon lesquels vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de début*
L'index de début est un entier positif indiquant *n* lignes au-dessus de la ligne actuelle. L'index de début comptabilise les points de données disponibles au-dessus de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*index de fin*
L'index de fin est un entier positif indiquant *n* lignes en dessous de la ligne actuelle. L'index de fin comptabilise les points de données disponibles en dessous de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule le minimum sur 12 mois de `sum(Revenue)`, partitionné par `SaleDate`. Le calcul comprend 12 lignes au-dessus et 0 lignes en dessous de la ligne actuelle.
```
windowMin
(
sum(Revenue),
[SaleDate ASC],
12,
0
)
```
La capture d'écran suivante affiche les résultats de cet exemple sur 12 mois. Le champ somme (Revenu) est ajouté au graphique pour montrer la différence entre le revenu et les revenus minimum sur la période de 12 mois.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/windowMin.png)
# windowSum
La fonction `windowSum` calcule la somme de la mesure regroupée dans une fenêtre personnalisée qui est divisée et triée par les attributs spécifiés. En règle générale, vous utilisez les fonctions de fenêtrage personnalisé sur une série chronologique, dans laquelle votre représentation visuelle affiche une métrique et un champ de date.
Les fonctions de fenêtrage ne sont pas prises en charge pour les versions MySQL antérieures à 8 et pour les versions MariaDB antérieures à 10.2.
## Syntaxe
Les crochets sont obligatoires. Pour voir quels arguments sont facultatifs, consultez les descriptions suivantes.
```
windowSum
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments
*mesure*
Les métriques regroupées pour lesquelles vous souhaitez obtenir la somme, par exemple `sum({Revenue})`.
Pour les moteurs MySQL, MariaDB et Amazon Aurora, avec une compatibilité MySQL, l'index de recherche est limité à 1. Les fonctions de fenêtrage ne sont pas prises en charge pour les versions MySQL antérieures à 8 et pour les versions MariaDB antérieures à 10.2.
*trier attribut*
Un ou plusieurs champs regroupés, des mesures ou des dimensions ou les deux, selon lesquels vous souhaitez trier les données, avec séparation par des virgules. Vous pouvez spécifier un ordre de tri croissant (**ASC**) ou décroissant (**DESC**).
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
*index de début*
L'index de début est un entier positif indiquant *n* lignes au-dessus de la ligne actuelle. L'index de début comptabilise les points de données disponibles au-dessus de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*index de fin*
L'index de fin est un entier positif indiquant *n* lignes en dessous de la ligne actuelle. L'index de fin comptabilise les points de données disponibles en dessous de la ligne actuelle, au lieu de compter les périodes réelles. Si vos données sont fragmentées (mois ou années manquants, par exemple), ajustez les index en conséquence.
*champ de partition*
(Facultatif) Une ou plusieurs mesures et dimensions selon lesquelles vous souhaitez effectuer la partition, avec séparation par des virgules.
Chaque champ de la liste est placé dans des accolades \$1\$1, s'il s'agit de plusieurs mots. La liste entière est placée entre crochets [ ].
## Exemple
L'exemple suivant calcule la somme mobile de `sum(Revenue)`, triée par mois `SaleDate`. Le calcul comprend deux lignes au-dessus et une ligne en dessous de la ligne actuelle.
```
windowSum
(
sum(Revenue),
[SaleDate ASC],
2,
1
)
```
L'exemple suivant montre une somme sur 12 mois.
```
windowSum(sum(Revenue),[SaleDate ASC],12,0)
```
La capture d'écran suivante affiche les résultats de cet exemple sur 12 mois. Le champ `sum(Revenue)` est ajouté au graphique pour montrer la différence entre le revenu et la somme des revenus sur une période de 12 mois.
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/windowSum.png)