Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Funzioni di calcolo delle tabelle
Quando stai analizzando i dati in uno specifico elemento visivo, puoi applicare i calcoli delle tabelle al set di dati corrente per scoprire in che modo le dimensioni influenzano le misure o come si influenzano a vicenda. I *dati visualizzati* sono il set di risultati basato sul set di dati corrente, con tutti i filtri, le selezioni di campi e le personalizzazioni applicati. Per vedere esattamente cosa è questo set di risultati, puoi esportare l'elemento visivo in un file. Una *funzione di calcolo delle tabelle* esegue operazioni sui dati per svelare le relazioni esistenti tra i campi.
In questa sezione, puoi trovare un elenco delle funzioni disponibili nei calcoli delle tabelle che puoi eseguire sui dati visualizzati in Amazon Quick.
Per visualizzare un elenco di funzioni ordinate per categoria, con brevi definizioni, consulta [Funzioni per](https://docs.aws.amazon.com/quicksight/latest/user/functions-by-category.html) categoria.
**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 funzione `difference` calcola la differenza tra una misura basata su un set di partizioni e ordinamenti e una misura basata su un'altra.
La funzione `difference` è supportata per l'uso con le analisi basate sui set di dati SPICE e delle query dirette.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
difference
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index,
,[ partition field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata per la quale si desidera vedere la differenza.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*indice di ricerca*
L'indice di ricerca può essere positivo o negativo, indicando una riga seguente nell'ordinamento (positivo) o una riga precedente nell'ordinamento (negativo). L'indice di ricerca può essere compreso tra 1 e 2.147.483.647. Per i motori MySQL, MariaDB e Aurora MySQL-Compatible Edition, l'indice di ricerca è limitato solo a 1.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola la differenza tra `sum({Billed Amount})`, ordinato per `Customer Region` in modo crescente, e la riga successiva, con partizionamento basato su `Service Line`.
```
difference(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1,
[{Service Line}]
)
```
L'esempio seguente calcola la differenza tra `Billed Amount` e la riga successiva, partizionato in base a (`[{Customer Region}]`). I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
difference(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1
)
```
Le lettere rosse mostrano il modo in cui viene aggiunto ogni importo (a \$1 b = c) per mostrare la differenza tra gli importi a e c.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/differenceCalc.png)
# distinctCountOver
La funzione `distinctCountOver` calcola il conteggio distinto dell'operando diviso dagli attributi specificati a un livello specificato. I livelli supportati sono `PRE_FILTER` e `PRE_AGG`. L'operando deve essere non aggregato.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
distinctCountOver
(
measure or dimension field
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*measure or dimension field*
La misura o la dimensione di cui si desidera eseguire il calcolo, ad esempio `{Sales Amt}`. I valori validi sono `PRE_FILTER` e `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
Il valore predefinito è `POST_AGG_FILTER` se vuoto. `POST_AGG_FILTER` non è un livello valido per questa operazione e genererà un messaggio di errore. Per ulteriori informazioni, consulta [Utilizzo di calcoli con riconoscimento dei livelli in Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente ottiene il conteggio distinto di `Sales` diviso su `City` e `State` al livello `PRE_AGG`.
```
distinctCountOver
(
Sales,
[City, State], PRE_AGG
)
```
# lag
La funzione `lag` calcola il valore lag (precedente) per una misura in base ai partizionamenti e agli ordinamenti specificati.
`lag` è supportato per l'uso con le analisi basate sui set di dati SPICE e delle query dirette.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
lag
(
lag
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index
,[ partition_field, ... ]
)]
)
```
## Arguments (Argomenti)
*misura*
La misura per la quale si desidera ottenere il valore lag. Può essere incluso un aggregato, ad esempio `sum({Sales Amt})`.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*indice di ricerca*
L'indice di ricerca può essere positivo o negativo, indicando una riga seguente nell'ordinamento (positivo) o una riga precedente nell'ordinamento (negativo). L'indice di ricerca può essere compreso tra 1 e 2.147.483.647. Per i motori MySQL, MariaDB e Amazon Aurora MySQL-Compatible Edition, l'indice di ricerca è limitato solo a 1.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola la precedente `sum(sales)`, partizionata in base allo stato di origine, in ordine crescente per `cancellation_code`.
```
lag
(
sum(Sales),
[cancellation_code ASC],
1,
[origin_state_nm]
)
```
L'esempio seguente usa un campo calcolato con `lag` per visualizzare l'importo della riga precedente accanto all'importo della riga corrente, ordinato per `Order Date`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
lag(
sum({Sales}),
[{Order Date} ASC],
1
)
```
Il seguente screenshot mostra i risultati dell'esempio.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/lagCalc.png)
L'esempio seguente usa un campo calcolato con `lag` per visualizzare l'importo delle vendite per la riga precedente accanto all'importo della riga corrente, ordinato per `Order Date` diviso per `Segment`.
```
lag
(
sum(Sales),
[Order Date ASC],
1, [Segment]
)
```
Il seguente screenshot mostra i risultati dell'esempio.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/lagCalc2.png)
# lead
La funzione `lead` calcola il valore iniziale (seguente) per una misura in base ai partizionamenti e agli ordinamenti specificati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
lead
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index,
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
La misura per la quale si desidera ottenere il valore lead. Può essere incluso un aggregato, ad esempio `sum({Sales Amt})`.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*indice di ricerca*
L'indice di ricerca può essere positivo o negativo, indicando una riga seguente nell'ordinamento (positivo) o una riga precedente nell'ordinamento (negativo). L'indice di ricerca può essere compreso tra 1 e 2.147.483.647. Per i motori MySQL, MariaDB e Amazon Aurora MySQL-Compatible Edition, l'indice di ricerca è limitato solo a 1.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola la successiva `sum(sales)`, partizionata in base allo stato di origine, in ordine crescente per `cancellation_code`.
```
lead
(
sum(sales),
[cancellation_code ASC],
1,
[origin_state_nm]
)
```
L'esempio seguente usa un campo calcolato con valore lead per visualizzare l'importo della riga successiva accanto all'importo della riga corrente, in ordine di `Customer Segment`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
lead(
sum({Billed Amount}),
[{Customer Segment} ASC],
1
)
```
Il seguente screenshot mostra i risultati dell'esempio.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/leadCalc.png)
# percentDifference
La funzione `percentDifference` calcola la differenza in percentuale tra il valore corrente e un valore di confronto, in base a partizioni, ordinamenti e indice di ricerca.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
percentDifference
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup index
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata per la quale si desidera vedere la differenza in percentuale.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*indice di ricerca*
L'indice di ricerca può essere positivo o negativo, indicando una riga seguente nell'ordinamento (positivo) o una riga precedente nell'ordinamento (negativo). L'indice di ricerca può essere compreso tra 1 e 2.147.483.647. Per i motori MySQL, MariaDB e Aurora MySQL-Compatible Edition, l'indice di ricerca è limitato solo a 1.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola la differenza in percentuale tra `sum(Sales)` per `State` corrente e precedente, in ordine di `Sales`.
```
percentDifference
(
sum(amount),
[sum(amount) ASC],
-1,
[State]
)
```
L'esempio seguente calcola la percentuale che un determinato valore `Billed Amount` è per un altro valore `Billed Amount`, in ordine di (`[{Customer Region} ASC]`). I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
percentDifference
(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1
)
```
Il seguente screenshot mostra i risultati dell'esempio. Le lettere rosse mostrano che il `Billed Amount` totale di `Customer Region` **APAC** è inferiore del 24% rispetto all'importo della regione **EMEA**.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/percentDifference.png)
# avgOver
La funzione `avgOver` calcola la media di una misura divisa per un elenco di dimensioni.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
avgOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
L'esempio seguente mostra la media cumulativa di `Billed Amount` per `Customer Region`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
avgOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Il seguente screenshot mostra i risultati dell'esempio. Con l'aggiunta di `Service Line`, viene visualizzato l'importo di fatturazione totale per ciascuno e la media di questi tre valori viene visualizzata nel campo calcolato.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/avgOver.png)
## Arguments (Argomenti)
*misura*
La misura di cui si desidera effettuare il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente recupera la media cumulativa di `sum(Sales)` partizionata per `City` e `State`.
```
avgOver
(
sum(Sales),
[City, State]
)
```
# countOver
La funzione `countOver` calcola il conteggio di una dimensione o una misura diviso per un elenco di dimensioni.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
countOver
(
measure or dimension field
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*measure or dimension field*
La misura o la dimensione di cui si desidera eseguire il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente ottiene il conteggio di `Sales` partizionato per `City` e `State`.
```
countOver
(
Sales,
[City, State]
)
```
L'esempio seguente ottiene il conteggio di `{County}` partizionato per `City` e `State`.
```
countOver
(
{County},
[City, State]
)
```
L'esempio seguente mostra il conteggio di `Billed Amount` per `Customer Region`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
countOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Il seguente screenshot mostra i risultati dell'esempio. Poiché non ci sono altri campi coinvolti, il conteggio è uno per ogni regione.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/countOver1.png)
Se si aggiungono altri campi, il conteggio cambia. Nello screenshot seguente, vengono aggiunti `Customer Segment` e `Service Line`. Ciascuno di tali campi contiene tre valori univoci. Con 3 segmenti, 3 linee di servizi e 3 regioni, il campo calcolato mostra 9.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/countOver2.png)
Se si aggiungono gli altri due campi ai campi di partizionamento nel campo calcolato, `countOver( sum({Billed Amount}), [{Customer Region}, {Customer Segment}, {Service Line}]`, il conteggio è di nuovo 1 per ogni riga.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/countOver.png)
# maxOver
La funzione `maxOver` calcola il valore massimo di una misura o una data diviso per un elenco di dimensioni.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
maxOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*misura*
La misura di cui si desidera effettuare il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente calcola la `sum(Sales)` massima, partizionata per `City` e `State`.
```
maxOver
(
sum(Sales),
[City, State]
)
```
L'esempio seguente mostra il valore massimo di `Billed Amount` per `Customer Region`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
maxOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Il seguente screenshot mostra i risultati dell'esempio. Con l'aggiunta di `Service Line`, viene visualizzato l'importo di fatturazione totale per ciascuno e il massimo di questi tre valori viene visualizzato nel campo calcolato.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/maxOver.png)
# minOver
La funzione `minOver` calcola il valore minimo di una misura o una data diviso per un elenco di dimensioni.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
minOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*misura*
La misura di cui si desidera effettuare il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente calcola la `sum(Sales)` minima, partizionata per `City` e `State`.
```
minOver
(
sum(Sales),
[City, State]
)
```
L'esempio seguente mostra il valore minimo di `Billed Amount` per `Customer Region`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
minOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Il seguente screenshot mostra i risultati dell'esempio. Con l'aggiunta di `Service Line`, viene visualizzato l'importo di fatturazione totale per ciascuno e il minimo di questi tre valori viene visualizzato nel campo calcolato.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/minOver.png)
# percentileOver
La funzione `percentileOver` calcola l'*n*-esimo percentile di una misura divisa per un elenco di dimensioni. In Quick sono disponibili due tipi di `percentileOver` calcolo:
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html) utilizza l'interpolazione lineare per determinare il risultato.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html) utilizza i valori effettivi per determinare il risultato.
La funzione `percentileOver` è un alias di `percentileDiscOver`.
# percentileContOver
La funzione `percentileContOver` calcola il percentile in base ai numeri effettivi in `measure`. Utilizza il raggruppamento e l'ordinamento applicati nei contenitori di campi. Il risultato viene partizionato in base alla dimensione specificata al livello di calcolo specificato.
Utilizza questa funzione per rispondere alla seguente domanda: Quali punti dati effettivi sono presenti in questo percentile? Per restituire il valore percentile più vicino presente nel set di dati, usa `percentileDiscOver`. Per restituire un valore percentile esatto che potrebbe non essere presente nel set di dati, usa invece `percentileContOver`.
## Sintassi
```
percentileContOver (
measure
, percentile-n
, [partition-by, …]
, calculation-level
)
```
## Arguments (Argomenti)
*misura*
Specifica un valore numerico da utilizzare per calcolare il percentile. L'argomento deve essere una misura o un parametro. I valori null vengono ignorati nel calcolo.
*percentile-n*
Il valore del percentile può essere qualsiasi costante numerica compresa tra 0 e 100. Un valore percentile di 50 calcola il valore mediano della misura.
*partition-by*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole. Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*livello di calcolo*
Specifica dove eseguire il calcolo in relazione all'ordine di valutazione. Esistono tre livelli di calcolo supportati:
+ PRE\$1FILTER
+ PRE\$1AGG
+ POST\$1AGG\$1FILTER (impostazione predefinita): per utilizzare questo livello di calcolo, specifica un'aggregazione su `measure`, ad esempio `sum(measure)`
PRE\$1FILTER e PRE\$1AGG vengono applicati prima che in una visualizzazione si verifichi l'aggregazione. Per questi due livelli di calcolo, non è possibile specificare un'aggregazione su `measure` nell'espressione del campo calcolato. Per ulteriori informazioni sui livelli di calcolo e su quando vengono applicati, consulta [Order of evaluation in Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/order-of-evaluation-quicksight.html) e [Using level-aware calcululations in](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html) Quick.
## Valori restituiti
Il risultato della funzione è un numero.
## Esempio di percentileContOver
L'esempio seguente aiuta a spiegare come funziona percentileContOver .
**Example Confronto dei livelli di calcolo per la mediana**
L'esempio seguente mostra la mediana di una dimensione (categoria) utilizzando diversi livelli di calcolo con la funzione `percentileContOver`. Il percentile è 50. Il set di dati viene filtrato in base a un campo regionale. Il codice per ogni campo calcolato è il seguente:
+ `example = left( category, 1 )` (un esempio semplificato).
+ `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 funzione `percentileDiscOver` calcola il percentile in base ai numeri effettivi in `measure`. Utilizza il raggruppamento e l'ordinamento applicati nei contenitori di campi. Il risultato viene partizionato in base alla dimensione specificata al livello di calcolo specificato. La funzione `percentileOver` è un alias di `percentileDiscOver`.
Utilizza questa funzione per rispondere alla seguente domanda: Quali punti dati effettivi sono presenti in questo percentile? Per restituire il valore percentile più vicino presente nel set di dati, usa `percentileDiscOver`. Per restituire un valore percentile esatto che potrebbe non essere presente nel set di dati, usa invece `percentileContOver`.
## Sintassi
```
percentileDiscOver (
measure
, percentile-n
, [partition-by, …]
, calculation-level
)
```
## Arguments (Argomenti)
*misura*
Specifica un valore numerico da utilizzare per calcolare il percentile. L'argomento deve essere una misura o un parametro. I valori null vengono ignorati nel calcolo.
*percentile-n*
Il valore del percentile può essere qualsiasi costante numerica compresa tra 0 e 100. Un valore percentile di 50 calcola il valore mediano della misura.
*partition-by*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole. Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*livello di calcolo*
Specifica dove eseguire il calcolo in relazione all'ordine di valutazione. Esistono tre livelli di calcolo supportati:
+ PRE\$1FILTER
+ PRE\$1AGG
+ POST\$1AGG\$1FILTER (impostazione predefinita): per utilizzare questo livello di calcolo, è necessario specificare un'aggregazione su `measure`, ad esempio `sum(measure)`.
PRE\$1FILTER e PRE\$1AGG vengono applicati prima che in una visualizzazione si verifichi l'aggregazione. Per questi due livelli di calcolo, non è possibile specificare un'aggregazione su `measure` nell'espressione del campo calcolato. Per ulteriori informazioni sui livelli di calcolo e su quando vengono applicati, consulta [Order of evaluation in Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/order-of-evaluation-quicksight.html) e [Using level-aware calcululations in](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html) Quick.
## Valori restituiti
Il risultato della funzione è un numero.
## Esempio di percentileDiscOver
L'esempio seguente aiuta a spiegare come funziona percentileDiscOver .
**Example Confronto dei livelli di calcolo per la mediana**
L'esempio seguente mostra la mediana di una dimensione (categoria) utilizzando diversi livelli di calcolo con la funzione `percentileDiscOver`. Il percentile è 50. Il set di dati viene filtrato in base a un campo regionale. Il codice per ogni campo calcolato è il seguente:
+ `example = left( category, 1 )` (un esempio semplificato).
+ `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 mediana**
L'esempio seguente calcola la mediana (il 50° percentile) di `Sales` diviso per `City` e `State`.
```
percentileDiscOver
(
Sales,
50,
[City, State]
)
```
L'esempio seguente calcola il 98° percentile di `sum({Billed Amount})` diviso per `Customer Region`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
percentileDiscOver
(
sum({Billed Amount}),
98,
[{Customer Region}]
)
```
Lo screenshot seguente mostra come appaiono questi due esempi in un grafico.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/percentilOver-50-98.png)
# percentOfTotal
La funzione `percentOfTotal` calcola la percentuale in cui una misura contribuisce al totale, in base alle dimensioni specificate.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
percentOfTotal
(
measure
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata per la quale si desidera vedere la percentuale del totale Al momento l'aggregazione `distinct count` non è supportata per `percentOfTotal`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente crea un calcolo per la percentuale del totale di `Sales` a cui ha contribuito ciascuno `State`.
```
percentOfTotal
(
sum(Sales),
[State]
)
```
L'esempio seguente calcola la percentuale di un valore `Billed Amount` specifico in confronto al totale di `Billed Amount`, diviso per (`[{Service Line} ASC]`). I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
percentOfTotal
(
sum( {Billed Amount} ),
[{Service Line}]
)
```
Il seguente screenshot mostra i risultati dell'esempio. Le parti evidenziate in rosso mostrano che il campo di partizionamento con il valore "`Billing`" presenta tre voci, una per ciascuna regione. L'importo totale fatturato per questa linea di servizi è diviso in tre percentuali, per un totale complessivo di 100%. Le percentuali vengono arrotondate ed è possibile che non sempre arrivino a 100%.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/percentOfTotal.png)
# periodOverPeriodDifference
La funzione `periodOverPeriodDifference` calcola la differenza di una misura su due periodi di tempo diversi, come specificato dalla granularità e dall'offset del periodo. A differenza del calcolo delle differenze, questa funzione utilizza un offset basato sulla data anziché un offset a dimensione fissa. Ciò garantisce che vengano confrontate solo le date corrette, anche se nel set di dati mancano dei punti dati.
## Sintassi
```
periodOverPeriodDifference(
measure,
date,
period,
offset)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata su cui vuoi eseguire il periodOverPeriod calcolo.
*dateTime*
La dimensione Data sulla quale vengono calcolati Period-Over-Period i calcoli.
*punto*
(Facoltativo) Il periodo di tempo durante il quale si esegue il calcolo. Granularità pari a `YEAR` significa calcolo `YearToDate`, `Quarter` significa `QuarterToDate` e così via. Le granularità valide includono `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
Il valore predefinito è la granularità della dimensione della data dell'elemento visivo.
*offset*
(Facoltativo) L'offset può essere un numero intero positivo o negativo che rappresenta il periodo di tempo precedente (specificato per periodo) con cui si desidera effettuare il confronto. Ad esempio, il periodo di un trimestre con offset 1 significa il confronto con il trimestre precedente.
Il valore predefinito è 1.
## Esempio
L'esempio seguente utilizza un campo calcolato `PeriodOverPeriod` per visualizzare la differenza tra gli importi delle vendite di ieri
```
periodOverPeriodDifference(sum(Sales), {Order Date})
```
![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/MonthOverMonthDifference.png)
L'esempio seguente utilizza un campo calcolato `PeriodOverPeriod` per visualizzare la differenza tra gli importi delle vendite dei due mesi precedenti L'esempio seguente confronta le vendite di `Mar2020` con `Jan2020`.
```
periodOverPeriodDifference(sum(Sales),{Order Date}, MONTH, 1)
```
![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/MonthOverMonthDifference2.png)
# periodOverPeriodLastValue
La funzione `periodOverPeriodLastValue` calcola l'ultimo valore (precedente) di una misura di un periodo di tempo precedente, come specificato dalla granularità e dall'offset del periodo. Questa funzione utilizza un offset basato sulla data anziché un offset di dimensioni fisse. Ciò garantisce che vengano confrontate solo le date corrette, anche se nel set di dati mancano dei punti dati.
## Sintassi
```
periodOverPeriodLastValue(
measure,
date,
period,
offset)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata per la quale si desidera vedere la differenza.
*data*
La dimensione della data sulla quale periodOverPeriod esegui i calcoli.
*punto*
(Facoltativo) Il periodo di tempo durante il quale si esegue il calcolo. Granularità pari a `YEAR` significa calcolo `YearToDate`, `Quarter` significa `QuarterToDate` e così via. Le granularità valide includono `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
L'impostazione predefinita di questo argomento è la granularità dell'aggregazione visiva
*offset*
(Facoltativo) L'offset può essere un numero intero positivo o negativo che rappresenta il periodo di tempo precedente (specificato per periodo) con cui si desidera effettuare il confronto. Ad esempio, il periodo di un trimestre con offset 1 significa il confronto con il trimestre precedente.
Il valore predefinito di questo argomento è 1.
## Esempio
L'esempio seguente calcola il valore delle vendite mese su mese con una granularità pari alla dimensione dell'elemento visivo e un offset predefinito di 1.
```
periodOverPeriodLastValue(sum(Sales), {Order Date})
```
L'esempio seguente calcola il valore delle vendite mese su mese con una granularità fissa pari a `MONTH` e un offset fisso di 1.
```
periodOverPeriodLastValue(sum(Sales), {Order Date},MONTH, 1)
```
![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/MonthOverMonthLastValue.png)
# periodOverPeriodPercentDifference
La funzione `periodOverPeriodPercentDifference` calcola la differenza in percentuale di una misura su due periodi di tempo diversi, come specificato dalla granularità e dall'offset del periodo. A differenza di percentDifference, questa funzione utilizza un offset basato sulla data anziché un offset a dimensione fissa. Ciò garantisce che vengano confrontate solo le date corrette, anche se nel set di dati mancano dei punti dati.
## Sintassi
```
periodOverPeriodPercentDifference(
measure,
date,
period,
offset)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata per la quale si desidera vedere la differenza.
*data*
La dimensione della data sulla quale periodOverPeriod esegui i calcoli.
*punto*
(Facoltativo) Il periodo di tempo durante il quale si esegue il calcolo. Granularità pari a `YEAR` significa calcolo `YearToDate`, `Quarter` significa `QuarterToDate` e così via. Le granularità valide includono `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
L'impostazione predefinita di questo argomento è la granularità dell'aggregazione visiva
*offset*
(Facoltativo) L'offset può essere un numero intero positivo o negativo che rappresenta il periodo di tempo precedente (specificato per periodo) con cui si desidera effettuare il confronto. Ad esempio, il periodo di un trimestre con offset 1 significa il confronto con il trimestre precedente.
Il valore predefinito di questo argomento è 1.
## Esempio
L'esempio seguente calcola la differenza percentuale delle vendite mese su mese con una granularità pari alla dimensione dell'elemento visivo e un offset predefinito di 1.
```
periodOverPeriodPercentDifference(sum(Sales),{Order Date})
```
L'esempio seguente calcola la differenza percentuale delle vendite mese su mese con una granularità fissa pari a `MONTH` e un offset fisso di 1.
```
periodOverPeriodPercentDifference(sum(Sales), {Order Date}, MONTH, 1)
```
![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/MonthOverMonthPercentDifference.png)
# periodToDateAvgOverTime
La funzione `periodToDateAvgOverTime` calcola la media di una misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
## Sintassi
```
periodToDateAvgOverTime(
measure,
dateTime,
period)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata di cui si desidera effettuare il calcolo.
*dateTime*
La dimensione della data sulla quale PeriodOverTime esegui i calcoli.
*punto*
(Facoltativo) Il periodo di tempo durante il quale si esegue il calcolo. Granularità pari a `YEAR` significa calcolo `YearToDate`, `Quarter` significa `QuarterToDate` e così via. Le granularità valide includono `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
Il valore predefinito è la granularità della dimensione della data dell'elemento visivo.
## Esempio
La seguente funzione calcola l'importo della tariffa media mese per mese.
```
periodToDateAvgOverTime(sum({fare_amount}), pickupDatetime, MONTH)
```
![\[Questa è un'immagine dei risultati del calcolo di esempio con illustrazioni.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDAvgOverTimeResults.png)
# periodToDateCountOverTime
La funzione `periodToDateCountOverTime` calcola il conteggio di una dimensione o misura per una determinata granularità temporale (ad esempio, un quarto) fino a un determinato punto nel tempo.
## Sintassi
```
periodToDateCountOverTime(
measure,
dateTime,
period)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata di cui si desidera effettuare il calcolo.
*dateTime*
La dimensione della data sulla quale PeriodOverTime esegui i calcoli.
*punto*
(Facoltativo) Il periodo di tempo durante il quale si esegue il calcolo. Granularità pari a `YEAR` significa calcolo `YearToDate`, `Quarter` significa `QuarterToDate` e così via. Le granularità valide includono `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
Il valore predefinito è la granularità della dimensione della data dell'elemento visivo.
## Esempio
L'esempio seguente calcola il numero di fornitori mese per mese.
```
periodToDateCountOverTime(count(vendorid), pickupDatetime, MONTH)
```
![\[Questa è un'immagine dei risultati del calcolo di esempio con illustrazioni.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDCountOverTimeResults.png)
# periodToDateMaxOverTime
La funzione `periodToDateMaxOverTime` calcola il massimo di una misura per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
## Sintassi
```
periodToDateMaxOverTime(
measure,
dateTime,
period)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata di cui si desidera effettuare il calcolo.
*dateTime*
La dimensione della data sulla quale PeriodOverTime esegui i calcoli.
*punto*
(Facoltativo) Il periodo di tempo durante il quale si esegue il calcolo. Granularità pari a `YEAR` significa calcolo `YearToDate`, `Quarter` significa `QuarterToDate` e così via. Le granularità valide includono `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
Il valore predefinito è la granularità della dimensione della data dell'elemento visivo.
## Esempio
L'esempio seguente calcola l'importo della tariffa massima mese per mese.
```
periodToDatemaxOverTime(max({fare_amount}), pickupDatetime, MONTH)
```
![\[Questa è un'immagine dei risultati del calcolo di esempio con illustrazioni.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDMaxOverTimeResults.png)
# periodToDateMinOverTime
La funzione `periodToDateMinOverTime` calcola il minimo di una misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
## Sintassi
```
periodToDateMinOverTime(
measure,
dateTime,
period)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata di cui si desidera effettuare il calcolo.
*dateTime*
La dimensione della data sulla quale PeriodOverTime esegui i calcoli.
*punto*
(Facoltativo) Il periodo di tempo durante il quale si esegue il calcolo. Granularità pari a `YEAR` significa calcolo `YearToDate`, `Quarter` significa `QuarterToDate` e così via. Le granularità valide includono `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
Il valore predefinito è la granularità della dimensione della data dell'elemento visivo.
## Esempio
L'esempio seguente calcola l'importo della tariffa minima mese per mese.
```
periodToDateMinOverTime(min({fare_amount}), pickupDatetime, MONTH)
```
![\[Questa è un'immagine dei risultati del calcolo di esempio con illustrazioni.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDMinOverTimeResults.png)
# periodToDateSumOverTime
La funzione `periodToDateSumOverTime` calcola la somma di una misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
## Sintassi
```
periodToDateSumOverTime(
measure,
dateTime,
period)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata di cui si desidera effettuare il calcolo.
*dateTime*
La dimensione della data sulla quale PeriodOverTime esegui i calcoli.
*punto*
(Facoltativo) Il periodo di tempo durante il quale si esegue il calcolo. Granularità pari a `YEAR` significa calcolo `YearToDate`, `Quarter` significa `QuarterToDate` e così via. Le granularità valide includono `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
Il valore predefinito è la granularità della dimensione della data dell'elemento visivo.
## Esempio
La seguente funzione restituisce l'importo totale della tariffa mese per mese.
```
periodToDateSumOverTime(sum({fare_amount}), pickupDatetime, MONTH)
```
![\[Questa è un'immagine dei risultati del calcolo di esempio con illustrazioni.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDSumOverTime-example-results.png)
# stdevOver
La funzione `stdevOver` calcola la deviazione standard della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a un campione.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
stdevOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*misura*
La misura di cui si desidera effettuare il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente calcola la deviazione standard di `sum(Sales)`, partizionata da `City` e `State`, in base a un campione.
```
stdevOver
(
sum(Sales),
[City, State]
)
```
L'esempio seguente calcola la deviazione standard di `Billed Amount` su `Customer Region`, in base a un campione. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
stdevOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# stdevpOver
La funzione `stdevpOver` calcola la deviazione standard della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a una popolazione parziale.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
stdevpOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*misura*
La misura di cui si desidera effettuare il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente calcola la deviazione standard di `sum(Sales)`, partizionata da `City` e `State`, in base a una popolazione parziale.
```
stdevpOver
(
sum(Sales),
[City, State]
)
```
L'esempio seguente calcola la deviazione standard di `Billed Amount` su `Customer Region`, in base a una popolazione parziale. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
stdevpOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# varOver
La funzione `varOver` calcola la varianza della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a un campione.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
varOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*misura*
La misura di cui si desidera effettuare il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente calcola la varianza di `sum(Sales)`, partizionata da `City` e `State`, in base a un campione.
```
varOver
(
sum(Sales),
[City, State]
)
```
L'esempio seguente calcola la varianza di `Billed Amount` su `Customer Region`, in base a un campione. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
varOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# varpOver
La funzione `varpOver` calcola la varianza della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a una popolazione parziale.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
varpOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*misura*
La misura di cui si desidera effettuare il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente calcola la varianza di `sum(Sales)`, partizionata da `City` e `State`, in base a una popolazione parziale.
```
varpOver
(
sum(Sales),
[City, State]
)
```
L'esempio seguente calcola la varianza di `Billed Amount` su `Customer Region`, in base a una popolazione parziale. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
varpOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# sumOver
La funzione `sumOver` calcola la somma di una misura divisa per un elenco di dimensioni.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
sumOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Arguments (Argomenti)
*misura*
La misura di cui si desidera effettuare il calcolo, ad esempio `sum({Sales Amt})`. Utilizza un'aggregazione se il livello di calcolo è impostato su `NULL` o su `POST_AGG_FILTER`. Non utilizzare un'aggregazione se il livello di calcolo è impostato su `PRE_FILTER` o su `PRE_AGG`.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente calcola la somma in esecuzione di `sum(Sales)`, partizionata per `City` e `State`.
```
sumOver
(
sum(Sales),
[City, State]
)
```
L'esempio seguente somma `Billed Amount` e `Customer Region`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
sumOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
Il seguente screenshot mostra i risultati dell'esempio. Con l'aggiunta di `Customer Segment`, l'importo di fatturazione totale per ciascuno viene sommato per la `Customer Region`, e viene visualizzato nel campo calcolato.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/sumOver.png)
# denseRank
La funzione `denseRank` calcola la classificazione di una misura o una dimensione rispetto alle partizioni specificate. Ogni voce viene conteggiata una sola volta, ignorando i duplicati, e viene assegnata una classificazione "senza buchi", in modo che i valori duplicati condividano la medesima classificazione.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
denseRank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*campo ordinamento*
Uno o più campi aggregati (misure o dimensioni o entrambe) in base ai quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente classifica in modo denso `max(Sales)`, in ordine decrescente, per `State` e `City`. A tutte le città con lo stesso `max(Sales)` viene assegnata la stessa classificazione e la successiva città viene classificata consecutivamente dopo le altre. Ad esempio, se tre città condividono la medesima classificazione, la quarta città viene classificata come seconda.
```
denseRank
(
[max(Sales) DESC],
[State, City]
)
```
L'esempio seguente classifica in modo denso `max(Sales)`, in ordine decrescente, per `State`. A tutti gli stati con lo stesso `max(Sales)` viene assegnata la stessa classificazione e il successivo stato viene classificato consecutivamente dopo gli altri. Ad esempio, se tre stati condividono la medesima classificazione, il quarto stato viene classificato come secondo.
```
denseRank
(
[max(Sales) DESC],
[State]
)
```
# rank
La funzione `rank` calcola la classificazione di una misura o una dimensione rispetto alle partizioni specificate. Ogni voce, anche quelle duplicate, viene contata una volta e viene assegnata una classificazione "con buchi" per costituire i valori duplicati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
rank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*campo ordinamento*
Una o più misure e le dimensioni aggregate in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli basati sui livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente classifica `max(Sales)`, in ordine decrescente, per `State` e `City`, all'interno dello `State` di **WA**. Alle città con lo stesso `max(Sales)` viene assegnata la stessa classificazione, ma la successiva classificazione include il conteggio di tutte le classificazioni precedentemente esistenti. Ad esempio, se tre città condividono la medesima classificazione, la quarta città viene classificata come quarta.
```
rank
(
[max(Sales) DESC],
[State, City]
)
```
L'esempio seguente classifica `max(Sales)`, in ordine crescente, per `State`. Agli stati con lo stesso `max(Sales)` viene assegnata la stessa classificazione, ma la successiva classificazione include il conteggio di tutte le classificazioni precedentemente esistenti. Ad esempio, se tre stati condividono la medesima classificazione, il quarto stato viene classificato come quarto.
```
rank
(
[max(Sales) ASC],
[State]
)
```
L'esempio seguente classifica `Customer Region` in base al totale di `Billed Amount`. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
rank(
[sum({Billed Amount}) DESC]
)
```
I seguenti screenshot mostrano i risultati dell'esempio, insieme al `Billed Amount`, per permettere di vedere come viene classificata ogni regione.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/rankCalc.png)
# percentileRank
La funzione `percentileRank` calcola la classificazione percentile di una misura o una dimensione rispetto alle partizioni specificate. Il valore del rango percentile (*x*) indica che l'elemento corrente è superiore alla*x*% dei valori nella partizione specificata. Il valore di classificazione percentile varia da 0 (inclusivo) a 100 (esclusivo).
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
percentileRank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ {partition_field}, ... ]
)
```
## Arguments (Argomenti)
*campo ordinamento*
Una o più misure e le dimensioni aggregate in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*calculation level*
(Facoltativo) Specifica il livello di calcolo da utilizzare:
+ **`PRE_FILTER`**: i calcoli di prefiltro vengono eseguiti prima dei filtri del set di dati.
+ **`PRE_AGG`**: i calcoli preaggregati vengono eseguiti prima che agli elementi visivi vengano applicati aggregazioni e *N* filtri in alto e in basso.
+ **`POST_AGG_FILTER`**: (impostazione predefinita) i calcoli delle tabelle vengono eseguiti quando compaiono gli elementi visivi.
Per impostazione predefinita, questo valore è impostato su `POST_AGG_FILTER` quando è vuoto. Per ulteriori informazioni, consulta [Utilizzo di calcoli che tengono conto dei livelli in Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Esempio
L'esempio seguente esegue una classificazione percentile di `max(Sales)` in ordine decrescente, per `State`.
```
percentileRank
(
[max(Sales) DESC],
[State]
)
```
L'esempio seguente esegue una classificazione percentile di `Customer Region` in base al `Billed Amount` totale. I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
percentileRank(
[sum({Billed Amount}) DESC],
[{Customer Region}]
)
```
I seguenti screenshot mostrano i risultati dell'esempio, insieme al `Billed Amount`, per consentire di vedere la modalità di confronto di ogni regione.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/percentileRank.png)
# runningAvg
La funzione `runningAvg` calcola una media in esecuzione per una misura in base alle dimensioni e agli ordinamenti specificati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
runningAvg
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Misura aggregata per cui desideri visualizzare la media mobile.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola una media mobile di `sum(Sales)`, ordinato in base a `Sales` e diviso per `City` e `State`.
```
runningAvg
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'esempio seguente calcola una media mobile di `Billed Amount`, ordinato in base al mese (`[truncDate("MM",Date) ASC]`). I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
runningAvg
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningCount
La funzione `runningCount` calcola un conteggio in esecuzione per una misura o una dimensione, in base alle dimensioni e agli ordinamenti specificati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
runningCount
(
measure_or_dimension
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*measure or dimension*
Misura o dimensione aggregata per cui desideri visualizzare il conteggio corrente.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola un conteggio corrente di `sum(Sales)`, ordinato in base a `Sales` e diviso per `City` e `State`.
```
runningCount
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'esempio seguente calcola un conteggio corrente di `Billed Amount`, ordinato in base al mese (`[truncDate("MM",Date) ASC]`). I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
runningCount
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningMax
La funzione `runningMax` calcola un valore massimo in esecuzione per una misura in base alle dimensioni e agli ordinamenti specificati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
runningMax
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Misura aggregata per cui desideri visualizzare il valore massimo corrente.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola un valore massimo corrente di `sum(Sales)`, ordinato in base a `Sales` e diviso per `City` e `State`.
```
runningMax
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'esempio seguente calcola un valore massimo corrente di `Billed Amount`, ordinato in base al mese (`[truncDate("MM",Date) ASC]`). I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
runningMax
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningMin
La funzione `runningMin` calcola un valore minimo corrente per una misura in base alle dimensioni e agli ordinamenti specificati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
runningMin
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Misura aggregata per cui desideri visualizzare il valore minimo corrente.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola un valore minimo corrente di `sum(Sales)`, ordinato in base a `Sales` e diviso per `City` e `State`.
```
runningMin
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'esempio seguente calcola un valore minimo corrente di `Billed Amount`, ordinato in base al mese (`[truncDate("MM",Date) ASC]`). I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
runningMin
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningSum
La funzione `runningSum` calcola una somma in esecuzione per una misura in base alle dimensioni e agli ordinamenti specificati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
runningSum
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Una misura aggregata per la quale si desidera vedere la somma in esecuzione.
*campo ordinamento*
Una o più misure e le dimensioni in base alle quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola una somma in esecuzione di `sum(Sales)`, ordinata in base a `Sales`, partizionata da `City` e `State`.
```
runningSum
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
L'esempio seguente calcola una somma in esecuzione di `Billed Amount`, ordinata in base al mese (`[truncDate("MM",Date) ASC]`). I campi nel calcolo della tabella sono nel contenitore dei campi dell'elemento visivo.
```
runningSum
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
Il seguente screenshot mostra i risultati dell'esempio. Le lettere rosse mostrano in che modo ogni importo viene aggiunto ( `a + b = c` ) al successivo, generando un nuovo totale.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/runningSum.png)
# firstValue
La funzione `firstValue` calcola il primo valore della dimensione o della misura aggregata divisa e ordinata in base agli attributi specificati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
firstValue
(
aggregated measure or dimension,
[ sort_attribute ASC_or_DESC, ... ],
[ partition_by_attribute, ... ]
)
```
## Arguments (Argomenti)
*misura o dimensione aggregata*
Una misura o una dimensione aggregata per cui desideri visualizzare il primo valore.
*sort attribute*
Uno o più campi aggregati (misure o dimensioni o entrambe) in base ai quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*divisione per attributo*
(Facoltativo) Una o più misure o dimensioni in base alle quali si desidera eseguire la divisione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola la prima `Destination Airport`, ordinata per `Flight Date`, divisa per `Flight Date` in ordine crescente e `Origin Airport`.
```
firstValue(
{Destination Airport}
[{Flight Date} ASC],
[
{Origin Airport},
{Flight Date}
]
)
```
# lastValue
La funzione `lastValue` calcola l'ultimo valore della dimensione o della misura aggregata divisa e ordinata in base agli attributi specificati.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
lastValue
(
aggregated measure or dimension,
[ sort_attribute ASC_or_DESC, ... ],
[ partition_by_attribute, ... ]
)
```
## Arguments (Argomenti)
*misura o dimensione aggregata*
Una misura o una dimensione aggregata per cui desideri visualizzare l'ultimo valore.
*sort attribute*
Uno o più campi aggregati (misure o dimensioni o entrambe) in base ai quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (`ASC`) o decrescente (`DESC`).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*divisione per attributo*
(Facoltativo) Una o più misure o dimensioni in base alle quali si desidera eseguire la divisione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola l'ultimo valore per `Destination Airport`. Questo calcolo viene ordinato in base al valore `Flight Date` e diviso per il valore `Flight Date` ordinato in ordine crescente e al valore `Origin Airport`.
```
lastValue(
[{Destination Airport}],
[{Flight Date} ASC],
[
{Origin Airport},
truncDate('DAY', {Flight Date})
]
)
```
# windowAvg
La funzione `windowAvg` calcola la media della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati. In genere puoi usare le funzioni finestra personalizzata in una serie temporale, in cui l'elemento visivo mostra un parametro e un campo di data. Ad esempio, puoi usare `windowAvg` per calcolare una media mobile, usate spesso per ridurre il rumore in un grafico a linee.
Le funzioni di Windows non sono supportate per le versioni di MySQL precedenti alla 8 e per le versioni di MariaDB precedenti alla 10.2.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
windowAvg
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Parametro aggregato per cui desideri ottenere la media, ad esempio `sum({Revenue})`.
*sort attribute*
Uno o più campi aggregati (misure o dimensioni o entrambe) in base ai quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*start index*
L'argomento start index è un numero intero positivo, che indica *n* righe sopra la riga corrente. L'argomento start index conteggia i punti dati disponibili sopra la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*end index*
L'argomento end index è un numero intero positivo, che indica *n* righe sotto la riga corrente. L'argomento end index conteggia i punti dati disponibili sotto la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola la media mobile di `sum(Revenue)`, diviso per `SaleDate`. Il calcolo include tre righe al di sopra e due righe al di sotto della riga corrente.
```
windowAvg
(
sum(Revenue),
[SaleDate ASC],
3,
2
)
```
Lo screenshot seguente mostra i risultati di questo esempio di media mobile. Il campo sum(Revenue) viene aggiunto al grafico per mostrare la differenza tra i ricavi e la media mobile dei ricavi.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/windowAvg.png)
# windowCount
La funzione `windowCount` calcola il conteggio della dimensione o della misura aggregata in una finestra personalizzata, divisa e ordinata in base agli attributi specificati. In genere puoi usare le funzioni finestra personalizzata in una serie temporale, in cui l'elemento visivo mostra un parametro e un campo di data.
Le funzioni di Windows non sono supportate per le versioni di MySQL precedenti alla 8 e per le versioni di MariaDB precedenti alla 10.2.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
windowCount
(
measure_or_dimension
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*measure or dimension*
Parametro aggregato per cui desideri ottenere la media, ad esempio `sum({Revenue})`.
*sort attribute*
Uno o più campi aggregati (misure o dimensioni o entrambe) in base ai quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*start index*
L'argomento start index è un numero intero positivo, che indica *n* righe sopra la riga corrente. L'argomento start index conteggia i punti dati disponibili sopra la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*end index*
L'argomento end index è un numero intero positivo, che indica *n* righe sotto la riga corrente. L'argomento end index conteggia i punti dati disponibili sotto la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola il conteggio corrente di `sum(Revenue)`, diviso per `SaleDate`. Il calcolo include tre righe al di sopra e due righe al di sotto della riga corrente.
```
windowCount
(
sum(Revenue),
[SaleDate ASC],
3,
2
)
```
# windowMax
La funzione `windowMax` calcola il massimo della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati. In genere puoi usare le funzioni finestra personalizzata in una serie temporale, in cui l'elemento visivo mostra un parametro e un campo di data. Puoi usare `windowMax` per identificare il valore massimo del parametro in un periodo di tempo.
Le funzioni di Windows non sono supportate per le versioni di MySQL precedenti alla 8 e per le versioni di MariaDB precedenti alla 10.2.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
windowMax
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Parametro aggregato per cui desideri ottenere la media, ad esempio `sum({Revenue})`.
*sort attribute*
Uno o più campi aggregati (misure o dimensioni o entrambe) in base ai quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*start index*
L'argomento start index è un numero intero positivo, che indica *n* righe sopra la riga corrente. L'argomento start index conteggia i punti dati disponibili sopra la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*end index*
L'argomento end index è un numero intero positivo, che indica *n* righe sotto la riga corrente. L'argomento end index conteggia i punti dati disponibili sotto la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se si tratta di più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola il valore massimo dei 12 mesi finali di `sum(Revenue)`, diviso per `SaleDate`. Il calcolo include 12 righe al di sopra e 0 righe al di sotto della riga corrente.
```
windowMax
(
sum(Revenue),
[SaleDate ASC],
12,
0
)
```
Lo screenshot seguente mostra i risultati di questo esempio finale di 12 mesi. Il campo sum(Revenue) viene aggiunto al grafico per mostrare la differenza tra i ricavi e i ricavi massimi dei 12 mesi finali.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/windowMax.png)
# windowMin
La funzione `windowMin` calcola il minimo della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati. In genere puoi usare le funzioni finestra personalizzata in una serie temporale, in cui l'elemento visivo mostra un parametro e un campo di data. Puoi usare `windowMin` per identificare il valore minimo del parametro in un periodo di tempo.
Le funzioni di Windows non sono supportate per le versioni di MySQL precedenti alla 8 e per le versioni di MariaDB precedenti alla 10.2.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
windowMin
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Parametro aggregato per cui desideri ottenere la media, ad esempio `sum({Revenue})`.
*sort attribute*
Uno o più campi aggregati (misure o dimensioni o entrambe) in base ai quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*start index*
L'argomento start index è un numero intero positivo, che indica *n* righe sopra la riga corrente. L'argomento start index conteggia i punti dati disponibili sopra la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*end index*
L'argomento end index è un numero intero positivo, che indica *n* righe sotto la riga corrente. L'argomento end index conteggia i punti dati disponibili sotto la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola il valore minimo dei 12 mesi finali di `sum(Revenue)`, diviso per `SaleDate`. Il calcolo include 12 righe al di sopra e 0 righe al di sotto della riga corrente.
```
windowMin
(
sum(Revenue),
[SaleDate ASC],
12,
0
)
```
Lo screenshot seguente mostra i risultati di questo esempio finale di 12 mesi. Il campo sum(Revenue) viene aggiunto al grafico per mostrare la differenza tra i ricavi e i ricavi minimi dei 12 mesi finali.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/windowMin.png)
# windowSum
La funzione `windowSum` calcola la somma della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati. In genere puoi usare le funzioni finestra personalizzata in una serie temporale, in cui l'elemento visivo mostra un parametro e un campo di data.
Le funzioni di Windows non sono supportate per le versioni di MySQL precedenti alla 8 e per le versioni di MariaDB precedenti alla 10.2.
## Sintassi
Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.
```
windowSum
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Arguments (Argomenti)
*misura*
Parametro aggregato per cui desideri ottenere la somma, ad esempio `sum({Revenue})`.
Per i motori MySQL, MariaDB e Amazon Aurora compatibile con MySQL, l'indice di ricerca è limitato solo a 1. Le funzioni di Windows non sono supportate per le versioni di MySQL precedenti alla 8 e per le versioni di MariaDB precedenti alla 10.2.
*sort attribute*
Uno o più campi aggregati (misure o dimensioni o entrambe) in base ai quali si desidera ordinare i dati, separati da virgole. È possibile specificare l'ordinamento crescente (**ASC**) o decrescente (**DESC**).
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
*start index*
L'argomento start index è un numero intero positivo, che indica *n* righe sopra la riga corrente. L'argomento start index conteggia i punti dati disponibili sopra la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*end index*
L'argomento end index è un numero intero positivo, che indica *n* righe sotto la riga corrente. L'argomento end index conteggia i punti dati disponibili sotto la riga corrente, invece di conteggiare gli effettivi periodi di tempo. Se i dati sono di tipo sparse (ad esempio, mesi o anni mancanti), modifica gli indici di conseguenza.
*partition field*
(Facoltativo) Una o più dimensioni in base alle quali si desidera eseguire la partizione, separate da virgole.
Ogni campo nell'elenco è racchiuso tra \$1\$1 (parentesi graffe), se è costituito da più di una parola. L'intero elenco è racchiuso tra [ ] (parentesi quadre).
## Esempio
L'esempio seguente calcola la somma mobile di `sum(Revenue)`, ordinato in base a `SaleDate`. Il calcolo include due righe al di sopra e una riga di sotto della riga corrente.
```
windowSum
(
sum(Revenue),
[SaleDate ASC],
2,
1
)
```
L'esempio seguente mostra una somma dei 12 mesi finali.
```
windowSum(sum(Revenue),[SaleDate ASC],12,0)
```
Lo screenshot seguente mostra i risultati di questo esempio di somma dei dodici mesi finali. Il campo `sum(Revenue)` viene aggiunto al grafico per mostrare la differenza tra i ricavi e la somma dei ricavi dei 12 mesi finali.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/windowSum.png)