

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à.

# Aggiunta di calcoli
<a name="working-with-calculated-fields"></a>

Crea campi calcolati per trasformare i dati utilizzando uno o più opzioni tra le seguenti: 
+ [Operatori](arithmetic-and-comparison-operators.md)
+ [Funzioni](functions.md)
+ Campi che contengono dati
+ Altri campi calcolati

Puoi aggiungere campi calcolati a un set di dati durante la preparazione dei dati oppure dalla pagina di analisi. Un campo calcolato aggiunto a un set di dati durante la preparazione dei dati è disponibile per tutte le analisi che utilizzano quel set di dati. Un campo calcolato aggiunto a un set di dati in un'analisi è disponibile solo per quell'analisi. Per ulteriori informazioni sull'aggiunta di campi calcolati, consulta i seguenti argomenti.

**Topics**
+ [Aggiunta di campi calcolati](adding-a-calculated-field-analysis.md)
+ [Ordine di valutazione in Amazon Quick Sight](order-of-evaluation-quicksight.md)
+ [Utilizzo di calcoli basati sul livello in Quick Sight](level-aware-calculations.md)
+ [Funzione di campo calcolata e riferimento dell'operatore per Amazon Quick](calculated-field-reference.md)

# Aggiunta di campi calcolati
<a name="adding-a-calculated-field-analysis"></a>

Crea campi calcolati per trasformare i dati utilizzando uno o più opzioni tra le seguenti: 
+ [Operatori](arithmetic-and-comparison-operators.md)
+ [Funzioni](functions.md)
+ Funzioni aggregate (puoi aggiungerle solo a un'analisi)
+ Campi che contengono dati
+ Altri campi calcolati

Puoi aggiungere campi calcolati a un set di dati durante la preparazione dei dati oppure dalla pagina di analisi. Un campo calcolato aggiunto a un set di dati durante la preparazione dei dati è disponibile per tutte le analisi che utilizzano quel set di dati. Un campo calcolato aggiunto a un set di dati in un'analisi è disponibile solo per quell'analisi. 

Le analisi supportano sia operazioni su riga singola che operazioni di aggregazione. Le operazioni su riga singola sono operazioni che restituiscono un risultato (potenzialmente) diverso per ogni riga. Le operazioni di aggregazione restituiscono risultati che sono sempre identici per i set di righe nel loro complesso. Ad esempio, se utilizzi una funzione di stringa semplice senza condizioni, ogni riga risulta modificata. Se utilizzi una funzione di aggregazione, essa verrà applicata a tutte le righe di un gruppo. Se richiedi l'importo totale delle vendite per gli Stati Uniti, lo stesso numero è valido per l'intero set. Se richiedi i dati relativi a uno stato specifico, l'importo totale delle vendite cambia in base al nuovo raggruppamento. Viene comunque restituito un risultato per l'intero set.

La creazione di un campo calcolato aggregato all'interno dell'analisi ti consentirà quindi di eseguire il drill-down dei dati. Il valore del campo aggregato viene ricalcolato in modo appropriato per ogni livello. Questo tipo di aggregazione non è possibile durante la preparazione del set di dati.

Ad esempio, supponiamo che si desideri calcolare la percentuale del profitto per ogni paese, regione e stato. All'analisi puoi aggiungere un campo calcolato `(sum(salesAmount - cost)) / sum(salesAmount)`. Questo campo viene quindi calcolato per ogni paese, regione e stato nel momento in cui l'analista esegue il drill-down nell'area geografica.

**Topics**
+ [Aggiunta di campi calcolati a un'analisi](#using-the-calculated-field-editor-analysis)
+ [Aggiunta di campi calcolati a un set di dati](#using-the-calculated-field-editor)
+ [Gestione dei valori decimali nei campi calcolati](#handling-decimal-fields)

## Aggiunta di campi calcolati a un'analisi
<a name="using-the-calculated-field-editor-analysis"></a>

Quando aggiungi un set di dati a un'analisi, ogni campo calcolato esistente nel set di dati viene aggiunto all'analisi. È possibile aggiungere campi calcolati aggiuntivi a livello di analisi per creare campi calcolati disponibili solo in quell'analisi.

**Aggiunta di un campo calcolato a un'analisi**

1. Apri la [console Quick](https://quicksight.aws.amazon.com/).

1. Apri l'analisi che desideri modificare.

1. Nel riquadro **Dati**, scegliere **Aggiungi** in alto a sinistra, quindi scegliere **\$1 CAMPO CALCOLATO**.

   1. Nell'editor di calcoli che si apre, procedi come segue:

   1. Inserisci un nome per il campo calcolato.

   1. Inserisci una formula utilizzando i campi del set di dati, delle funzioni e degli operatori.

1. Al termine, scegli **Save** (Salva).

Per ulteriori informazioni su come creare formule utilizzando le funzioni disponibili in Quick Sight, vedere[Funzione di campo calcolata e riferimento dell'operatore per Amazon QuickFunzioni e operatori](calculated-field-reference.md).

## Aggiunta di campi calcolati a un set di dati
<a name="using-the-calculated-field-editor"></a>

Gli autori di Amazon Quick Sight possono generare campi calcolati durante la fase di preparazione dei dati della creazione di un set di dati. Quando crei un campo calcolato per un set di dati, il campo diventa una nuova colonna nel set di dati. Tutte le analisi che utilizzano il set di dati ereditano i campi calcolati del set di dati.

Se il campo calcolato funziona a livello di riga e il set di dati è memorizzato inSPICE, Quick Sight calcola e materializza il risultato in. SPICE Se il campo calcolato si basa su una funzione di aggregazione, Quick Sight conserva la formula ed esegue il calcolo quando viene generata l'analisi. Questo tipo di campo calcolato è chiamato campo calcolato non materializzato.

**Aggiunta o modifica di un campo calcolato per un set di dati**

1. Aprire il set di dati che si desidera utilizzare. Per ulteriori informazioni, consulta [Modifica di set di dati](edit-a-data-set.md).

1. Nella pagina di preparazione dei dati, completa una delle seguenti operazioni:
   + Per creare un nuovo campo, scegli **Aggiungi campo calcolato** sulla sinistra.
   + Per modificare un campo calcolato esistente, selezionalo da **Campi calcolati** sulla sinistra, quindi scegli **Modifica** dal menu contestuale (fai clic con il pulsante destro del mouse).

1. Nell'editor di calcolo, inserisci un nome descrittivo in **Aggiungi titolo** per assegnare un nome al nuovo campo calcolato. Questo nome apparirà nell'elenco dei campi del set di dati, quindi dovrebbe essere simile agli altri campi. Per questo esempio, assegnamo un nome al campo `Total Sales This Year`.

1. (Facoltativo) Aggiungi un commento, ad esempio per spiegare a cosa serve l'espressione, racchiudendo il testo tra barre e asterischi.

   ```
   /* Calculates sales per year for this year*/
   ```

1. Identifica i parametri, le funzioni e gli altri elementi da utilizzare. Per questo esempio, dobbiamo identificare quanto segue:
   + Il parametro da usare
   + Le funzioni `ifelse` e `datediff`

   Vogliamo creare una istruzione del tipo "Se la vendita è avvenuta durante quest'anno, mostra le vendite totali, altrimenti mostra 0".

   Per aggiungere la funzione `ifelse`, apri l'elenco **Funzioni**. Scegli **Tutto** per chiudere l'elenco di tutte le funzioni. Ora dovresti vedere i gruppi di funzioni: **Aggregato**, **Condizionale**, **Data** e così via. 

   Scegli **Condizionale**, quindi fai doppio clic su `ifelse` per aggiungerlo all'area di lavoro. 

   ```
   ifelse()
   ```

1. Posiziona il cursore all'interno della parentesi nell'area di lavoro e aggiungi tre righe vuote.

   ```
   ifelse(
                                               
                                               
                                               
   )
   ```

1. Posiziona il cursore sulla prima riga vuota, individua la funzione `dateDiff`. È elencata in **Funzioni** in **Date**. Puoi trovarla anche inserendo **date** in **Cerca funzioni**. La funzione `dateDiff` restituisce tutte le funzioni che hanno *`date`* come parte del loro nome. Non restituisce tutte le funzioni elencate in **Date**; ad esempio, la funzione `now` non è presente nei risultati della ricerca.

   Fai doppio clic su `dateDiff` per aggiungerla alla prima riga vuota dell'istruzione `ifelse`. 

   ```
   ifelse(
   dateDiff()                                            
                                               
                                               
   )
   ```

   Aggiungi i parametri utilizzati da `dateDiff`. Posiziona il cursore all'interno delle parentesi `dateDiff` per iniziare ad aggiungere `date1`, `date2` e `period`:

   1. Per `date1`: il primo parametro è il campo che contiene la data. Individualo in **Campi** e aggiungilo all'area di lavoro facendo doppio clic su di esso o inserendone il nome. 

   1. Per `date2`, aggiungi una virgola, quindi scegli `truncDate()` per **Funzioni**. All'interno della parentesi, aggiungi periodo e data, in questo modo: **truncDate( "YYYY", now() )**

   1. Per `period`: aggiungi una virgola dopo `date2` e inserisci **YYYY**. Questo è il periodo dell'anno. Per visualizzare un elenco di tutti i periodi supportati, cerca `dateDiff` nell'elenco **Funzioni** e apri la documentazione scegliendo **Scopri di più**. Se stai già visualizzando la documentazione, come stai facendo ora, consulta [dateDiff](dateDiff-function.md).

   Aggiungi degli spazi per una maggiore leggibilità, se lo desideri. L'espressione avrà un aspetto simile al seguente.

   ```
   ifelse(
      dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" )                                       
                                               
                                               
   )
   ```

1. Specifica il valore di ritorno. Per il nostro esempio, il primo parametro in `ifelse` deve restituire il valore `TRUE` o `FALSE`. Poiché vogliamo l'anno corrente e lo stiamo confrontando con quest'anno, specifichiamo che l'istruzione `dateDiff` deve restituire `0`. La parte `if` di `ifelse` viene valutata true per le righe in cui non vi è differenza tra l'anno di vendita e l'anno corrente.

   ```
      dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0 
   ```

   Per creare un campo `TotalSales` per l'anno passato, puoi cambiare `0` in `1`.

   Un altro modo per fare la stessa cosa è usare `addDateTime` invece di `truncDate`. Quindi, per ogni anno precedente, si modifica il primo parametro per `addDateTime` in modo che rappresenti ciascun anno. A tale scopo, si utilizza `-1` per l'anno scorso, `-2` per l'anno precedente e così via. Se si utilizza `addDateTime`, si lascia la funzione `dateDiff` `= 0` per ogni anno.

   ```
      dateDiff( {Discharge Date}, addDateTime(-1, "YYYY", now() ) ,"YYYY" ) = 0 /* Last year */
   ```

1. Sposta il cursore sulla prima riga vuota, appena sotto `dateDiff`. Aggiungi una virgola. 

   Per la parte `then` dell'istruzione `ifelse`, dobbiamo scegliere la misura (parametro) che contiene l'importo delle vendite, `TotalSales`.

   Per scegliere un campo, apri l'elenco **Campi** e fai doppio clic su un campo per aggiungerlo allo schermo. Oppure puoi inserire il nome. Aggiungi parentesi graffe `{ }` attorno ai nomi che contengono spazi. È probabile che il parametro abbia un nome diverso. Puoi sapere quale campo è un parametro dal simbolo numerico che lo precede (**\$1**).

   L'espressione dovrebbe avere il seguente aspetto.

   ```
   ifelse(
      dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0
      ,{TotalSales}                            
                                              
   )
   ```

1. Aggiungi una clausola `else`. La funzione `ifelse` non ne richiede una, ma vogliamo aggiungerla. Ai fini della rendicontazione, di solito non si desidera avere valori nulli, perché a volte le righe con valori null vengono omesse. 

   Abbiamo impostato la parte else di ifelse su `0`. Il risultato è che questo campo è `0` per le righe che contengono le vendite degli anni precedenti.

   Per fare ciò, nella riga vuota aggiungi una virgola e poi un `0`. Se hai aggiunto il commento all'inizio, l'espressione `ifelse` completa dovrebbe essere simile alla seguente.

   ```
   /* Calculates sales per year for this year*/
   ifelse(
      dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0
      ,{TotalSales}                            
      ,0                                         
   )
   ```

1. Salva il tuo lavoro selezionando **Salva** in alto a destra. 

   Se ci sono errori nell'espressione, l'editor visualizza un messaggio di errore in basso. Controlla se nell'espressione è presente una linea ondulata rossa, quindi posiziona il cursore su quella linea per vedere qual è il messaggio di errore. Gli errori più comuni includono punteggiatura mancante, parametri mancanti, errori di ortografia e tipi di dati non validi.

   Per uscire senza apportare modifiche, scegli **Annulla**.

**Aggiunta di un valore di parametro a un campo calcolato**

1. Puoi fare riferimento ai parametri nei campi calcolati. Aggiungendo il parametro all'espressione, si aggiunge il valore corrente di quel parametro.

1. Per aggiungere un parametro, apri l'elenco **Parametri** e seleziona il parametro di cui desideri includere il valore. 

1. (Facoltativo) Per aggiungere manualmente un parametro all'espressione, digita il nome del parametro. Quindi racchiudilo tra parentesi graffe `{}` e aggiungi il prefisso `$`, ad esempio `${parameterName}`.

È possibile modificare il tipo di dati di qualsiasi campo del set di dati, inclusi i tipi di campi calcolati. Puoi scegliere solo i tipi di dati che corrispondono ai dati presenti nel campo.

**Modifica del tipo di dati di un campo calcolato**
+ Per **Campi calcolati** (a sinistra), scegli il campo che desideri modificare, quindi scegli **Cambia tipo di dati** dal menu contestuale (clic con il pulsante destro del mouse).

A differenza degli altri campi del set di dati, i campi calcolati non possono essere disabilitati. Invece, eliminali. 

**Eliminazione di un campo calcolato**
+ Per **Campi calcolati** (a sinistra), scegli il campo che desideri modificare, quindi scegli **Elimina** dal menu contestuale (clic con il pulsante destro del mouse).

## Gestione dei valori decimali nei campi calcolati
<a name="handling-decimal-fields"></a>

Quando il set di dati utilizza la modalità query diretta, il calcolo del tipo di dati decimale è determinato dal comportamento del motore di origine da cui proviene il set di dati. In alcuni casi particolari, Quick Sight applica gestioni speciali per determinare il tipo di dati del calcolo di output.

Quando il set di dati utilizza la modalità di interrogazione SPICE e viene materializzato un campo calcolato, il tipo di dati del risultato dipende dagli operatori di funzione specifici e dal tipo di dati dell'input. Le tabelle seguenti mostrano il comportamento previsto per alcuni campi calcolati numerici.

**Operatori unari**

La tabella seguente mostra quale tipo di dati viene emesso in base all'operatore utilizzato e al tipo di dati del valore immesso. Ad esempio, se si immette un numero intero in un calcolo `abs`, il tipo di dati del valore di output è intero.


****  
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/adding-a-calculated-field-analysis.html)

**Operatori binari**

La tabella seguente mostra quale tipo di dati viene emesso in base ai tipi di dati dei due valori immessi. Ad esempio, per un operatore aritmetico, se si forniscono due tipi di dati interi, il risultato del calcolo viene restituito come numero intero.

Per gli operatori di base (\$1, -, \$1):


|  | **Numero intero** | **Fisso con valori decimali** | **Flottante decimale** | 
| --- | --- | --- | --- | 
|  **Numero intero**  |  Numero intero  |  Fisso con valori decimali  |  Flottante decimale  | 
|  **Fisso con valori decimali**  |  Fisso con valori decimali  |  Fisso con valori decimali  |  Flottante decimale  | 
|  **Flottante decimale**  |  Flottante decimale  |  Flottante decimale  |  Flottante decimale  | 

Per gli operatori di divisione (/):


|  | **Numero intero** | **Fisso con valori decimali** | **Flottante decimale** | 
| --- | --- | --- | --- | 
|  **Numero intero**  |  Flottante decimale  |  Flottante decimale  |  Flottante decimale  | 
|  **Fisso con valori decimali**  |  Flottante decimale  |  Fisso con valori decimali  |  Flottante decimale  | 
|  **Flottante decimale**  |  Flottante decimale  |  Flottante decimale  |  Flottante decimale  | 

Per operatori esponenziali e mod (^, %):


|  | **Numero intero** | **Fisso con valori decimali** | **Flottante decimale** | 
| --- | --- | --- | --- | 
|  **Numero intero**  |  Flottante decimale  |  Flottante decimale  |  Flottante decimale  | 
|  **Fisso con valori decimali**  |  Flottante decimale  |  Flottante decimale  |  Flottante decimale  | 
|  **Flottante decimale**  |  Flottante decimale  |  Flottante decimale  |  Flottante decimale  | 

# Ordine di valutazione in Amazon Quick Sight
<a name="order-of-evaluation-quicksight"></a>

Quando apri o aggiorni un'analisi, prima di visualizzarla, Amazon Quick Sight valuta tutto ciò che è configurato nell'analisi in una sequenza specifica. Amazon Quick Sight traduce la configurazione in una query che può essere eseguita da un motore di database. La query restituisce i dati in modo simile indipendentemente dal fatto che ci si connetta a un database, a una fonte SaaS (Software as a Service) o al motore di analisi Amazon Quick Sight ([SPICE](spice.md)). 

Se comprendi l'ordine in cui viene valutata la configurazione, conosci la sequenza che determina quando uno specifico filtro o calcolo viene applicato ai dati.

La figura seguente mostra l'ordine di valutazione. La colonna a sinistra mostra l'ordine di valutazione quando non è coinvolta alcuna finestra di calcolo (LAC-W) basata sui livelli o una funzione di aggregazione (LAC-A). La seconda colonna mostra l'ordine di valutazione per le analisi che contengono campi calcolati per calcolare le espressioni LAC-W a livello di prefiltro (`PRE_FILTER`). La terza colonna mostra l'ordine di valutazione per le analisi che contengono campi calcolati per calcolare le espressioni LAC-W a livello di preaggregazione (`PRE_AGG`). L'ultima colonna mostra l'ordine di valutazione per le analisi che contengono campi calcolati per calcolare le espressioni LAC-A. Seguendo l'illustrazione, è disponibile una spiegazione più dettagliata dell'ordine di valutazione. Per ulteriori informazioni sui calcoli basati sui livelli, consulta [Utilizzo di calcoli basati sul livello in Quick Sight](level-aware-calculations.md).

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/order-of-evaluation2.png)


L'elenco seguente mostra la sequenza in cui Amazon Quick Sight applica la configurazione nell'analisi. Tutto ciò che è configurato nel set di dati avviene al di fuori dell'analisi, ad esempio calcoli a livello di set di dati, filtri e impostazioni di sicurezza. Tutto ciò si applica ai dati sottostanti. L'elenco seguente descrive solo ciò che accade all'interno dell'analisi. 

1. **Livello di prefiltro LAC-W**: valuta i dati alla cardinalità originale della tabella prima dei filtri di analisi

   1. **Calcoli semplici**: calcoli a livello scalare senza aggregazioni o calcoli a finestra. Ad esempio, `date_metric/60, parseDate(date, 'yyyy/MM/dd'), ifelse(metric > 0, metric, 0), split(string_column, '|' 0)`.

   1. **Funzione LAC-W PRE\$1FILTER**: se nella visualizzazione è coinvolta un'espressione LAC-W PRE\$1FILTER, Amazon Quick Sight calcola innanzitutto la funzione finestra a livello di tabella originale, prima di qualsiasi filtro. Se l'espressione LAC-W PRE\$1FILTER viene utilizzata nei filtri, viene applicata a questo punto. Ad esempio, `maxOver(Population, [State, County], PRE_FILTER) > 1000`.

1. **LAC-W PRE\$1AGG**: valuta i dati alla cardinalità della tabella originale prima delle aggregazioni

   1. **Filtri aggiunti durante l'analisi**: a questo punto vengono applicati i filtri creati per i campi non aggregati negli elementi visivi, che sono simili alle clausole WHERE. Ad esempio, `year > 2020`.

   1. **Funzione LAC-W PRE\$1AGG**: se nella visualizzazione è coinvolta un'espressione LAC-W PRE\$1AGG, Amazon Quick Sight calcola la funzione finestra prima di applicare qualsiasi aggregazione. Se l'espressione LAC-W PRE\$1AGG viene utilizzata nei filtri, viene applicata a questo punto. Ad esempio, `maxOver(Population, [State, County], PRE_AGG) > 1000`.

   1. **Filtri N superiore/inferiore**: filtri configurati in base alle dimensioni per visualizzare N elementi. top/bottom 

1. **Livello LAC-A**: valuta le aggregazioni a livello personalizzato, prima delle aggregazioni dell'elemento visivo

   1. **Aggregazioni a livello personalizzato**: se nell'elemento visivo è coinvolta un'espressione LAC-A, viene calcolata a questo punto. In base alla tabella dopo i filtri sopra menzionati, Amazon QuickSight calcola l'aggregazione, raggruppata in base alle dimensioni specificate nei campi calcolati. Ad esempio, `max(Sales, [Region])`.

1. **Livello dell'elemento visivo**: valuta le aggregazioni a livello di elemento visivo e i calcoli delle tabelle successive all'aggregazione, con le configurazioni rimanenti applicate negli elementi visivi

   1. **Aggregazioni a livello di elemento visivo**: le aggregazioni di elementi visivi devono essere sempre applicate tranne nei casi di tabelle tabulari (dove la dimensione è vuota). Con questa impostazione, le aggregazioni vengono calcolate in base ai campi nei contenitori di campi, raggruppate in base alle dimensioni inserite negli elementi visivi. Se un filtro è costruito sulle aggregazioni, viene applicato a questo punto, in modo simile alle clausole HAVING. Ad esempio, `min(distance) > 100`.

   1. **Calcoli delle tabelle**: se nell'immagine è presente un calcolo della tabella post-aggregazione (dovrebbe utilizzare un'espressione aggregata come operando) a cui si fa riferimento nell'elemento visivo, viene calcolato a questo punto. Amazon Quick Sight esegue calcoli delle finestre dopo aggregazioni visive. Allo stesso modo, vengono applicati i filtri basati su tali calcoli.

   1. **Calcoli di altre categorie**: questo tipo di calcolo esiste solo nei line/bar/pie/donut grafici. Per ulteriori informazioni, consulta [Limiti di visualizzazione](working-with-visual-types.md#display-limits).

   1. **Totali e subtotali**: i totali e i subtotali vengono calcolati in grafici ad anello (solo totali), tabelle (solo totali) e tabelle pivot, se richiesto.

# Utilizzo di calcoli basati sul livello in Quick Sight
<a name="level-aware-calculations"></a>


|  | 
| --- |
|    Si applica a: Enterprise Edition e Standard Edition  | 

Con i *calcoli con riconoscimento del livello* (LAC) puoi specificare il livello di granularità che desideri utilizzare per calcolare le funzioni delle finestre o le funzioni aggregate. Esistono due tipi di funzioni LAC: funzioni di calcolo con riconoscimento del livello - aggregate (LAC-A) e funzioni di calcolo con riconoscimento del livello - finestra (LAC-W).

**Topics**
+ [Funzioni LAC-A](#level-aware-calculations-aggregate)
+ [Funzioni LAC-W](#level-aware-calculations-window)

## Calcolo con riconoscimento del livello: funzioni aggregate (LAC-A)
<a name="level-aware-calculations-aggregate"></a>

Con le funzioni LAC-A, è possibile specificare a quale livello raggruppare il calcolo. Aggiungendo un argomento a una funzione di aggregazione esistente, ad esempio `sum() , max() , count()`, è possibile definire qualsiasi livello di raggruppamento per livello desiderato per l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo. Esempio:

```
sum(measure,[group_field_A])
```

Per utilizzare le funzioni LAC-A, digitale direttamente nell'editor di calcolo aggiungendo i livelli di aggregazione previsti come secondo argomento tra parentesi. Di seguito è riportato un esempio di funzione aggregata e una funzione LAC-A, a scopo di confronto.
+ Funzione aggregata: `sum({sales})`
+ Funzione LAC-A: `sum({sales}, [{Country},{Product}])`

I risultati LAC-A vengono calcolati con il livello specificato tra parentesi `[ ]`, che può essere utilizzato come operando di una funzione aggregata. Il livello di raggruppamento della funzione aggregata è a livello visivo, con i campi **Raggruppa per** aggiunti al contenitore di campi dell'elemento visivo. 

Oltre a creare una chiave di gruppo LAC statica tra parentesi `[ ]`, puoi adattarla dinamicamente ai campi visivi raggruppati per gruppi, inserendo un parametro `$visualDimensions` tra parentesi. Si tratta di un parametro fornito dal sistema, a differenza del parametro definito dall'utente. Il parametro `[$visualDimensions]` rappresenta i campi aggiunti al contenitore di campi **Raggruppa per** nell'elemento visivo corrente. Gli esempi seguenti mostrano come aggiungere dinamicamente chiavi di gruppo o rimuovere chiavi di gruppo dalle dimensioni dell'elemento visivo
+ LAC-A con chiave di gruppo aggiunta dinamicamente: `sum({sales}, [${visualDimensions},{Country},{Products}])`

  Prima di calcolare l'aggregazione a livello di elemento visivo, calcola la somma delle vendite, il raggruppamento per `country`, `products` e qualsiasi altro campo nel contenitore di campi **Raggruppa per**. 
+ LAC-A con chiave di gruppo rimossa dinamicamente: `sum({sales}, [${visualDimensions},!{Country},!{Products}])` 

  Prima di calcolare l'aggregazione a livello di elemento visivo, calcola la somma delle vendite, raggruppando i campi nel contenitore di campi **Raggruppa per**, tranne `country` e `product`. 

È possibile specificare la chiave di gruppo aggiunta o la chiave di gruppo rimossa nell'espressione LAC, ma non entrambe.

Le funzioni LAC-A sono supportate per le seguenti funzioni di aggregazione:
+ [avg](avg-function.md)
+ [count](count-function.md)
+ [distinct\$1count](distinct_count-function.md)
+ [max](max-function.md)
+ [median](median-function.md)
+ [min](min-function.md)
+ [percentile](percentile-function.md)
+ [percentileCont](percentileCont-function.md)
+ [percentileDisc (percentile)](percentileDisc-function.md)
+ [stdev](stdev-function.md)
+ [stdevp](stdevp-function.md)
+ [sum](sum-function.md)
+ [var](var-function.md)
+ [varp](varp-function.md)

### Esempi LAC-A
<a name="level-aware-calculations-aggregate-examples"></a>

Le funzioni LAC-A consentono di effettuare le seguenti operazioni:
+ Eseguire calcoli indipendenti dai livelli nell'elemento visivo. Ad esempio, se utilizzi il seguente calcolo, i numeri di vendita vengono aggregati solo a livello di Paese, ma non in altre dimensioni (Regione o Prodotto) nell'elemento visivo.

  ```
  sum({Sales},[{Country}])
  ```
+ Eseguire calcoli per le dimensioni che non sono presenti nell'elemento visivo. Ad esempio, se disponi della funzione seguente, puoi calcolare le vendite totali medie in un Paese per regione.

  ```
  sum({Sales},[{Country}])
  ```

  Sebbene Paese non sia incluso nell'elemento visivo, la funzione LAC-A aggrega prima le vendite a livello di Paese, quindi il calcolo a livello di elemento visivo genera il numero medio per ogni regione. Se la funzione LAC-A non viene utilizzata per specificare il livello, le vendite medie vengono calcolate al livello granulare più basso (il livello di base del set di dati) per ogni Regione (visualizzato nella colonna delle vendite).
+ Usa LAC-A in combinazione con altre funzioni aggregate e funzioni LAC-W. Esistono due modi per nidificare le funzioni LAC-A con altre funzioni.
  + È possibile scrivere una sintassi nidificata quando si crea un calcolo. Ad esempio, la funzione LAC-A può essere nidificata con una funzione LAC-W per calcolare le vendite totali per Paese del prezzo medio di ciascun prodotto:

    ```
    sum(avgOver({Sales},[{Product}],PRE_AGG),[{Country}])
    ```
  + Quando si aggiunge una funzione LAC-A a un elemento visivo, il calcolo può essere ulteriormente nidificato con funzioni aggregate a livello di elemento visivo selezionate nel contenitore di campi. Per ulteriori informazioni su come modificare l'aggregazione dei campi nell'elemento visivo, consulta [Modifica o aggiunta di funzioni di aggregazione a un campo mediante un contenitore di campi](changing-field-aggregation.md#change-field-aggregation-field-wells).

### Limitazioni LAC-A
<a name="level-aware-calculations-aggregate-limitations"></a>

Le seguenti limitazioni si applicano alle funzioni LAC-A:
+ Le funzioni LAC-A sono supportate per tutte le funzioni aggregate additive e non additive, come `sum()`, `count()` e `percentile()`. Le funzioni LAC-A non sono supportate per le funzioni di aggregazione condizionale che terminano con «if», come `sumif()` e`countif()`, né per le funzioni di aggregazione periodica che iniziano con "«, come e. periodToDate `periodToDateSum()` `periodToDateMax()`
+ I totali a livello di riga e colonna non sono attualmente supportati per le funzioni LAC-A nelle tabelle e nelle tabelle pivot. Quando aggiungi totali a livello di riga o colonna al grafico, il numero totale verrà visualizzato come vuoto. Le altre dimensioni non LAC non vengono influenzate.
+ Le funzioni LAC-A nidificate non sono attualmente supportate. È supportata una capacità limitata delle funzioni LAC-A nidificate con funzioni aggregate normali e funzioni LAC-W.

  Ad esempio, le seguenti funzioni sono valide:
  + `Aggregation(LAC-A())`. Ad esempio: `max(sum({sales}, [{country}]))`
  + `LAC-A(LAC-W())`. Ad esempio: `sum(sumOver({Sales},[{Product}],PRE_AGG), [{Country}])`

  Le seguenti funzioni non sono valide:
  + `LAC-A(Aggregation())`. Ad esempio: `sum(max({sales}), [{country}])`
  + `LAC-A(LAC-A())`. Ad esempio: `sum(max({sales}, [{country}]),[category])`
  + `LAC-W(LAC-A())`. Ad esempio: `sumOver(sum({Sales},[{Product}]),[{Country}],PRE_AGG)`

## Calcolo in base al livello: funzioni a finestra (LAC-W)
<a name="level-aware-calculations-window"></a>

Con le funzioni LAC-W, è possibile specificare la finestra o la partizione per il calcolo. Le funzioni LAC-W sono un gruppo di funzioni di finestra, come `sumover()`, `(maxover)` e `denseRank`, che è possibile eseguire a livello di prefiltro o preaggregazione. Ad esempio: `sumOver(measure,[partition_field_A],pre_agg)`.

Le funzioni LAC-W venivano chiamate aggregazioni con riconoscimento dei livelli (LAA).

Le funzioni LAC-W ti aiutano a rispondere ai seguenti tipi di domande:
+ Quanti dei miei clienti hanno effettuato un solo ordine di acquisto? Oppure 10? Oppure 50? Vogliamo che l'elemento visivo utilizzi il conteggio come dimensione anziché come parametro nell'elemento visivo.
+ Quali sono le vendite totali per segmento di mercato per i clienti la cui spesa per il ciclo di vita è superiore a 100.000 USD? L'elemento visivo deve mostrare solo il segmento di mercato e il totale delle vendite per ciascuno di essi.
+ Qual è il contributo di ciascun settore al profitto dell'intera azienda (percentuale del totale)? Vogliamo essere in grado di filtrare l'elemento visivo per mostrare alcuni dei settori e in che modo contribuiscono alle vendite totali per i settori visualizzati. Tuttavia, vogliamo anche vedere la percentuale di ogni settore delle vendite totali dell'intera azienda (inclusi i settori filtrati). 
+ Quali sono le vendite totali in ogni categoria rispetto alla media del settore? La media del settore deve includere tutte le categorie, anche dopo il filtraggio.
+ Come vengono raggruppati i clienti negli intervalli di spesa cumulativi? Vogliamo utilizzare il raggruppamento come dimensione anziché come parametro. 

Per domande più complesse, puoi inserire un calcolo o un filtro prima che Quick Sight arrivi a un punto specifico della valutazione delle impostazioni. Per influenzare direttamente i risultati, aggiungi una parola chiave a livello di calcolo a un calcolo delle tabelle. Per ulteriori informazioni su come Quick Sight valuta le interrogazioni, consulta. [Ordine di valutazione in Amazon Quick Sight](order-of-evaluation-quicksight.md)

I seguenti livelli di calcolo sono supportati per le funzioni LAC-W:
+ **`PRE_FILTER`**— Prima di applicare i filtri dell'analisi, Quick Sight valuta i calcoli dei prefiltri. Quindi applica tutti i filtri configurati su questi calcoli di prefiltro.
+ **`PRE_AGG`**— Prima di calcolare le aggregazioni a livello di visualizzazione, Quick Sight esegue calcoli preaggregati. Quindi applica tutti i filtri configurati su questi calcoli preaggregati. Questa operazione avviene prima di applicare *N* filtri superiori e inferiori.

Puoi utilizzare le parole chiave `PRE_FILTER` o `PRE_AGG` come parametro nelle seguenti funzioni di calcolo delle tabelle. Quando specifichi un livello di calcolo, nella funzione utilizzi una misura non aggregata. Per esempio, è possibile utilizzare `countOver({ORDER ID}, [{Customer ID}], PRE_AGG)`. Utilizzando `PRE_AGG`, specifichi che l'operazione `countOver` viene eseguita a livello di preaggregazione. 
+ [avgOver](avgOver-function.md)
+ [countOver](countOver-function.md)
+ [denseRank](denseRank-function.md)
+ [distinctCountOver](distinctCountOver-function.md)
+ [minOver](minOver-function.md)
+ [maxOver](maxOver-function.md)
+ [percentileRank](percentileRank-function.md)
+ [rank](rank-function.md)
+ [stdevOver](stdevOver-function.md)
+ [stdevpOver](stdevpOver-function.md)
+ [sumOver](sumOver-function.md)
+ [varOver](varOver-function.md)
+ [varpOver](varpOver-function.md)

Per impostazione predefinita, il primo parametro di ogni funzione deve essere una misura aggregata. Se utilizzi `PRE_FILTER` o `PRE_AGG`, utilizzi una misura non aggregata per il primo parametro. 

Per le funzioni LAC-W, l'aggregazione visiva utilizza il valore `MIN` per eliminare i duplicati. Per modificare l'aggregazione, apri il menu contestuale del campo (clic con il pulsante destro del mouse), quindi scegli un'aggregazione diversa.

Per esempi di quando e come utilizzare le funzioni LAC-W in scenari di vita reale, consulta il seguente post nel AWS Big Data Blog: [Crea approfondimenti avanzati utilizzando Level Aware Aggregations in Amazon](https://aws.amazon.com/jp/blogs/big-data/create-advanced-insights-using-level-aware-aggregations-in-amazon-quicksight/). QuickSight 

# Funzione di campo calcolata e riferimento dell'operatore per Amazon Quick
<a name="calculated-field-reference"></a>

Puoi aggiungere campi calcolati a un set di dati durante la preparazione dei dati oppure dalla pagina di analisi. Un campo calcolato aggiunto a un set di dati durante la preparazione dei dati è disponibile per tutte le analisi che utilizzano quel set di dati. Un campo calcolato aggiunto a un set di dati in un'analisi è disponibile solo per quell'analisi. 

Puoi creare campi calcolati per trasformare i tuoi dati utilizzando le funzioni e gli operatori riportati di seguito.

**Topics**
+ [Operatori](arithmetic-and-comparison-operators.md)
+ [Funzioni per categoria](functions-by-category.md)
+ [Funzioni](functions.md)
+ [Funzioni di aggregazione](calculated-field-aggregations.md)
+ [Funzioni di calcolo delle tabelle](table-calculation-functions.md)

# Operatori
<a name="arithmetic-and-comparison-operators"></a>

Puoi utilizzare gli operatori seguenti nei campi calcolati. Quick utilizza l'ordine standard delle operazioni: parentesi, esponenti, moltiplicazione, divisione, addizione, sottrazione (PEMDAS). I confronti uguale a (=) e non uguale a (<>) prevedono la distinzione tra lettere maiuscole e minuscole. 
+ Addizione (\$1)
+ Sottrazione (-)
+ Moltiplicazione (\$1)
+ Divisione (/)
+ Modulo (%): vedi anche `mod()` nell'elenco seguente.
+ Potenza (^): vedi anche `exp()` nell'elenco seguente.
+ Uguale a (=)
+ Non uguale a (<>)
+ Maggiore di (>)
+ Maggiore di o uguale a (>=)
+ Minore di (<)
+ Minore di o uguale a (<=)
+ AND
+ O
+ NOT

Amazon Quick supporta l'applicazione delle seguenti funzioni matematiche a un'espressione.
+ `[https://docs.aws.amazon.com/quicksight/latest/user/mod-function.html](https://docs.aws.amazon.com/quicksight/latest/user/mod-function.html)(number, divisor)`: trova il resto dopo aver diviso un numero per un divisore.
+ `[https://docs.aws.amazon.com/quicksight/latest/user/log-function.html](https://docs.aws.amazon.com/quicksight/latest/user/log-function.html)(expression) `: restituisce il logaritmo in base 10 di una determinata espressione. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/ln-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ln-function.html)(expression) `: restituisce il logaritmo naturale di una determinata espressione. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/abs-function.html](https://docs.aws.amazon.com/quicksight/latest/user/abs-function.html)(expression) `: restituisce il valore assoluto di una determinata espressione. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/sqrt-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sqrt-function.html)(expression) `: restituisce la radice quadrata di una determinata espressione. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/exp-function.html](https://docs.aws.amazon.com/quicksight/latest/user/exp-function.html)(expression) `: restituisce il logaritmo naturale in base *e* elevato alla potenza di una determinata espressione. 

Per semplificare la lettura dei calcoli lunghi, puoi usare le parentesi in modo da rendere chiari raggruppamenti e precedenza. Nella seguente istruzione, le parentesi non sono necessarie. L'istruzione di moltiplicazione viene elaborata per prima, quindi il risultato viene aggiunto a 5, restituendo il valore 26. Tuttavia, le parentesi rendono più semplice la lettura dell'istruzione e pertanto rimangono.

```
5 + (7 * 3)
```

Poiché le parentesi vengono prima nell'ordine delle operazioni, puoi modificare l'ordine in cui vengono applicati gli operatori. Ad esempio, di seguito, l'istruzione di addizione viene elaborata per prima, quindi il risultato viene moltiplicato per 3, restituendo il valore 36.

```
(5 + 7) * 3
```

## Esempio: operatori aritmetici
<a name="operator-example-multiple-operators"></a>

L'esempio seguente utilizza più operatori aritmetici per determinare il totale di una vendita in seguito a uno sconto.

```
(Quantity * Amount) - Discount
```

## Esempio: (/) Divisione
<a name="operator-example-division-operators"></a>

L'esempio seguente utilizza la divisione per dividere 3 per 2. Viene restituito un valore pari a 1,5. Amazon Quick utilizza divisioni in virgola mobile.

```
3/2
```

## Esempio: (=) uguale a
<a name="operator-example-equal"></a>

L'utilizzo di = esegue un confronto dei valori che prevede una distinzione tra lettere maiuscole e minuscole. Le righe in cui il confronto è TRUE vengono incluse nel set dei risultati. 

Nel seguente esempio, le righe in cui il campo `Region` è **South** vengono incluse nei risultati. Se `Region` è **south**, tali righe vengono escluse.

```
Region = 'South'
```

Nel seguente esempio, il confronto viene valutato come FALSE. 

```
Region = 'south'
```

L'esempio seguente mostra un confronto che converte `Region` in tutte lettere maiuscole (**SOUTH**) e lo confronta con **SOUTH**. Vengono restituite le righe in cui la regione è **south**, **South** o **SOUTH**.

```
toUpper(Region) = 'SOUTH'
```

## Esempio: (<>)
<a name="operator-example-not-equal"></a>

Il simbolo non uguale a <> significa *minore di o maggiore di*. 

Quindi, l'affermazione **x<>1** può essere interpretata come *se x è minore di 1 OR se x è maggiore di 1*. Entrambi < e > vengono valutati insieme. In altre parole, *se x è un valore qualsiasi eccetto 1*. Oppure, *x non è uguale a 1*. 

**Nota**  
Utilizza <>, non \$1=.

L'esempio seguente confronta `Status Code` con un valore numerico. Vengono restituite le righe in cui `Status Code` non è uguale a **1**.

```
statusCode <> 1
```

L'esempio seguente confronta più valori `statusCode`. In questo caso, per i record attivi `activeFlag = 1`. Questo esempio restituisce le righe in cui si applica uno dei seguenti casi:
+ Per i record attivi, vengono mostrate le righe in cui lo stato non è 1 o 2
+ Per i record inattivi, vengono mostrate le righe in cui lo stato è 99 o -1

```
( activeFlag = 1 AND (statusCode <> 1 AND statusCode <> 2) )
OR
( activeFlag = 0 AND (statusCode= 99 OR statusCode= -1) )
```

## Esempio: (^)
<a name="operator-example-power"></a>

Il simbolo di potenza `^` significa *alla potenza di*. Puoi utilizzare l'operatore di potenza in qualsiasi campo numerico, con qualsiasi esponente valido. 

L'esempio seguente è una semplice espressione di 2 alla potenza di 4 o (2 \$1 2 \$1 2 \$1 2). Viene restituito il valore 16.

```
2^4
```

L'esempio seguente calcola la radice quadrata del campo del fatturato.

```
revenue^0.5
```

## Esempio: AND, OR e NOT
<a name="operator-example-and-or-not"></a>

L'esempio seguente utilizza AND, OR e NOT per confrontare più espressioni. A tal fine, utilizza operatori condizionali per etichettare i migliori clienti che hanno effettuato più di 10 ordini NON di Washington o dell'Oregon con una promozione speciale. Se non viene restituito alcun valore, viene utilizzato il valore "n/a" (n/d).

```
ifelse(( (NOT (State = 'WA' OR State = 'OR')) AND Orders > 10), 'Special Promotion XYZ', 'n/a')
```

## Esempio: creazione di elenchi di confronto come "in" o "non in"
<a name="operator-example-in-or-not-in"></a>

Questo esempio utilizza gli operatori per creare un confronto per trovare i valori esistenti (o non) in uno specifico elenco di valori.

L'esempio seguente confronta `promoCode` con un elenco specificato di valori. Questo esempio restituisce le righe in cui `promoCode` è nell'elenco **(1, 2, 3)**.

```
promoCode    = 1
OR promoCode = 2
OR promoCode = 3
```

L'esempio seguente confronta `promoCode` con un elenco specificato di valori. Vengono restituite le righe in cui `promoCode` NON (NOT) è nell'elenco **(1, 2, 3)**.

```
NOT(promoCode = 1
OR promoCode  = 2
OR promoCode  = 3
)
```

Un altro modo per esprimere il medesimo concetto è di fornire un elenco in cui `promoCode` non è uguale ad alcuna voce nell'elenco.

```
promoCode     <> 1
AND promoCode <> 2
AND promoCode <> 3
```

## Esempio: creazione di un confronto "tra"
<a name="operator-example-between"></a>

Questo esempio utilizza gli operatori di confronto per creare un confronto che mostra i valori esistenti tra un valore e un altro.

L'esempio seguente esamina `OrderDate` e restituisce le righe in cui `OrderDate` è compreso tra il primo giorno e l'ultimo giorno del 2016. In questo caso, vogliamo che il primo e l'ultimo giorno siano inclusi, pertanto usiamo "o uguale a" negli operatori di confronto. 

```
OrderDate >= "1/1/2016" AND OrderDate <= "12/31/2016"
```

# Funzioni per categoria
<a name="functions-by-category"></a>

In questa sezione, puoi trovare un elenco delle funzioni disponibili in Amazon Quick, ordinate per categoria.

**Topics**
+ [Funzioni di aggregazione](#aggregate-functions)
+ [Funzioni condizionali](#conditional-functions)
+ [Funzioni di data](#date-functions)
+ [Funzioni numeriche](#numeric-functions)
+ [Funzioni matematiche](#mathematical-functions)
+ [Funzioni stringa](#string-functions)
+ [Calcoli delle tabelle](#table-calculations)

## Funzioni di aggregazione
<a name="aggregate-functions"></a>

Le funzioni di aggregazione per i campi calcolati in Amazon Quick includono quanto segue. Questi sono disponibili solo durante l'analisi e la visualizzazione. Ciascuna di queste funzioni restituisce i valori raggruppati in base alla dimensione o alle dimensioni scelte. Per ogni aggregazione, viene anche applicata un'aggregazione condizionale. Queste eseguono lo stesso tipo di aggregazione, in base a una condizione. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/avg-function.html](https://docs.aws.amazon.com/quicksight/latest/user/avg-function.html) calcola la media del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte.
+ [https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html) calcola la media sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/count-function.html](https://docs.aws.amazon.com/quicksight/latest/user/count-function.html) calcola il numero di valori in una dimensione o misura, raggruppati in base alla dimensione o alle dimensioni scelte. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html) calcola il conteggio sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/distinct_count-function.html](https://docs.aws.amazon.com/quicksight/latest/user/distinct_count-function.html) calcola il numero di valori distinti in una dimensione o misura, raggruppati in base alla dimensione o alle dimensioni scelte. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html) calcola il conteggio distinto sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/max-function.html](https://docs.aws.amazon.com/quicksight/latest/user/max-function.html) restituisce il valore massimo della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte.
+ [https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html) calcola il massimo sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/median-function.html](https://docs.aws.amazon.com/quicksight/latest/user/median-function.html) restituisce il valore medio della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte.
+ [https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html) calcola la mediana sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/min-function.html](https://docs.aws.amazon.com/quicksight/latest/user/min-function.html) restituisce il valore minimo della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte.
+ [https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html) calcola il minimo sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentile-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentile-function.html) (alias di `percentileDisc`) calcola l'*n*-esimo percentile della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileCont-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileCont-function.html) calcola l'*n*-esimo percentile in base a una distribuzione continua dei numeri della misura specificata, raggruppati per la dimensione o le dimensioni scelte. 
+ [percentileDisc(percentile)](https://docs.aws.amazon.com/quicksight/latest/user/percentileDisc-function.html) calcola l'ennesimo percentile *in* base ai numeri effettivi della misura specificata, raggruppati per la dimensione o le dimensioni scelte. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateAvg-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateAvg-function.html) calcola la media dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateCount-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateCount-function.html) calcola il numero di valori in una dimensione o misura per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento, inclusi i duplicati.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMax-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMax-function.html) restituisce il valore massimo della misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMedian-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMedian-function.html) restituisce il valore della mediana della misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMin-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMin-function.html) restituisce il valore minimo della misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDatePercentile-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDatePercentile-function.html) calcola il percentile dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDatePercentileCont-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDatePercentileCont-function.html) calcola il percentile dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateStDev-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateStDev-function.html) calcola la deviazione standard dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateStDevP-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateStDevP-function.html) calcola la deviazione standard della popolazione dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateSum-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateSum-function.html) calcola l'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateVar-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateVar-function.html) calcola la varianza campione dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateVarP-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateVarP-function.html) calcola la varianza di popolazione dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdev-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdev-function.html)) calcola la deviazione standard del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte, in base a un campione.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html) calcola la deviazione standard del campione sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevp-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevp-function.html) calcola la deviazione standard del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte, in base a una popolazione parziale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html) calcola la deviazione della popolazione sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/var-function.html](https://docs.aws.amazon.com/quicksight/latest/user/var-function.html)) calcola la varianza dei set di numeri nella misura specificata, raggruppati per la dimensione o le dimensioni scelte, in base a un campione.
+ [https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) calcola la varianza campione sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/varp-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varp-function.html)) calcola la varianza dei set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte, in base a una popolazione parziale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html) calcola la varianza della popolazione sulla base di una dichiarazione condizionale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/sum-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sum-function.html)) aggiunge il set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte.
+ [https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html) calcola la somma sulla base di una dichiarazione condizionale.

## Funzioni condizionali
<a name="conditional-functions"></a>

Le funzioni condizionali per i campi calcolati in Amazon Quick includono quanto segue:
+ [https://docs.aws.amazon.com/quicksight/latest/user/coalesce-function.html](https://docs.aws.amazon.com/quicksight/latest/user/coalesce-function.html) restituisce il valore del primo argomento che non è null.
+ [https://docs.aws.amazon.com/quicksight/latest/user/ifelse-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ifelse-function.html) valuta un set di *se*, gli abbinamenti delle espressioni *poi* e restituisce il valore dell'argomento *poi* per il primo argomento *se* che valuta come true.
+ [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) valuta un'espressione per vedere se è inclusa in un determinato elenco di valori.
+ [https://docs.aws.amazon.com/quicksight/latest/user/isNotNull-function.html](https://docs.aws.amazon.com/quicksight/latest/user/isNotNull-function.html) valuta un'espressione per capire se non è null.
+ [https://docs.aws.amazon.com/quicksight/latest/user/isNull-function.html](https://docs.aws.amazon.com/quicksight/latest/user/isNull-function.html) valuta un'espressione per capire se è null. Se l'espressione è null, `isNull` restituisce true, altrimenti restituisce false.
+ [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html) valuta un'espressione per vedere se non è inclusa in un determinato elenco di valori.
+ [https://docs.aws.amazon.com/quicksight/latest/user/nullIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/nullIf-function.html) confronta due espressioni. Se sono uguali, la funzione restituisce null. Se non sono uguali, la funzione restituisce la prima espressione.
+ [https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html](https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html) restituisce un'espressione che corrisponde alla prima etichetta uguale all'espressione della condizione.

## Funzioni di data
<a name="date-functions"></a>

Le funzioni relative alla data per i campi calcolati in Amazon Quick includono quanto segue:
+ [https://docs.aws.amazon.com/quicksight/latest/user/addDateTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/addDateTime-function.html) aggiunge o sottrae un'unità di tempo alla data o all'ora fornite.
+ [https://docs.aws.amazon.com/quicksight/latest/user/addWorkDays-function.html](https://docs.aws.amazon.com/quicksight/latest/user/addWorkDays-function.html) aggiunge o sottrae il numero specificato di giorni lavorativi alla data o all'ora fornite.
+ [https://docs.aws.amazon.com/quicksight/latest/user/dateDiff-function.html](https://docs.aws.amazon.com/quicksight/latest/user/dateDiff-function.html) restituisce la differenza in giorni tra due campi della data 
+ [https://docs.aws.amazon.com/quicksight/latest/user/epochDate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/epochDate-function.html) converte una data epoca (Unix epoch) in una data standard 
+ [https://docs.aws.amazon.com/quicksight/latest/user/extract-function.html](https://docs.aws.amazon.com/quicksight/latest/user/extract-function.html) restituisce una parte specificata di un valore di data 
+ [https://docs.aws.amazon.com/quicksight/latest/user/formatDate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/formatDate-function.html) formatta una data utilizzando un modello specificato. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/isWorkDay-function.html](https://docs.aws.amazon.com/quicksight/latest/user/isWorkDay-function.html) restituisce TRUE se un determinato valore di data e ora è un giorno lavorativo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/netWorkDays-function.html](https://docs.aws.amazon.com/quicksight/latest/user/netWorkDays-function.html) restituisce il numero di giorni lavorativi compresi tra i due valori di data forniti.
+ [https://docs.aws.amazon.com/quicksight/latest/user/now-function.html](https://docs.aws.amazon.com/quicksight/latest/user/now-function.html) restituisce la data e l'ora correnti, utilizzando le impostazioni di un database oppure UTC per file e Salesforce. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/truncDate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/truncDate-function.html) restituisce un valore di data che rappresenta una parte specificata di una data 

## Funzioni numeriche
<a name="numeric-functions"></a>

Le funzioni numeriche per i campi calcolati in Amazon Quick includono quanto segue:
+ [https://docs.aws.amazon.com/quicksight/latest/user/ceil-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ceil-function.html) arrotonda un valore decimale al successivo intero più alto 
+ [https://docs.aws.amazon.com/quicksight/latest/user/decimalToInt-function.html](https://docs.aws.amazon.com/quicksight/latest/user/decimalToInt-function.html) converte un valore decimale in un intero 
+ [https://docs.aws.amazon.com/quicksight/latest/user/floor-function.html](https://docs.aws.amazon.com/quicksight/latest/user/floor-function.html) riduce un valore decimale al successivo intero più basso 
+ [https://docs.aws.amazon.com/quicksight/latest/user/intToDecimal-function.html](https://docs.aws.amazon.com/quicksight/latest/user/intToDecimal-function.html) converte un valore intero in un decimale 
+ [https://docs.aws.amazon.com/quicksight/latest/user/round-function.html](https://docs.aws.amazon.com/quicksight/latest/user/round-function.html) arrotonda un valore decimale all'intero più vicino oppure, se è specificata la dimensione, alla posizione decimale più vicina 

## Funzioni matematiche
<a name="mathematical-functions"></a>

Le funzioni matematiche per i campi calcolati in Amazon Quick includono quanto segue: 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/mod-function.html](https://docs.aws.amazon.com/quicksight/latest/user/mod-function.html)(number, divisor)`: trova il resto dopo aver diviso un numero per un divisore.
+ `[https://docs.aws.amazon.com/quicksight/latest/user/log-function.html](https://docs.aws.amazon.com/quicksight/latest/user/log-function.html)(expression) `: restituisce il logaritmo in base 10 di una determinata espressione. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/ln-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ln-function.html)(expression) `: restituisce il logaritmo naturale di una determinata espressione. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/abs-function.html](https://docs.aws.amazon.com/quicksight/latest/user/abs-function.html)(expression) `: restituisce il valore assoluto di una determinata espressione. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/sqrt-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sqrt-function.html)(expression) `: restituisce la radice quadrata di una determinata espressione. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/exp-function.html](https://docs.aws.amazon.com/quicksight/latest/user/exp-function.html)(expression) `: restituisce il logaritmo naturale in base *e* elevato alla potenza di una determinata espressione. 

## Funzioni stringa
<a name="string-functions"></a>

Le funzioni di stringa (testo) per i campi calcolati in Amazon Quick includono quanto segue:
+ [https://docs.aws.amazon.com/quicksight/latest/user/concat-function.html](https://docs.aws.amazon.com/quicksight/latest/user/concat-function.html) concatena due o più stringhe. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/contains-function.html](https://docs.aws.amazon.com/quicksight/latest/user/contains-function.html) verifica se un'espressione contiene una sottostringa. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/endsWith-function.html](https://docs.aws.amazon.com/quicksight/latest/user/endsWith-function.html) verifica se l'espressione termina con la sottostringa specificata.
+ [https://docs.aws.amazon.com/quicksight/latest/user/left-function.html](https://docs.aws.amazon.com/quicksight/latest/user/left-function.html) restituisce il numero specificato di caratteri più a sinistra di una stringa. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/locate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/locate-function.html) individua una sottostringa all'interno di un'altra stringa e restituisce il numero di caratteri prima della sottostringa. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/ltrim-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ltrim-function.html) rimuove lo spazio vuoto precedente da una stringa. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/parseDate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/parseDate-function.html) analizza una stringa per determinare se contiene un valore di data e, se trovata, restituisce la data. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/parseDecimal-function.html](https://docs.aws.amazon.com/quicksight/latest/user/parseDecimal-function.html) analizza una stringa per determinare se contiene un valore decimale. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/parseInt-function.html](https://docs.aws.amazon.com/quicksight/latest/user/parseInt-function.html) analizza una stringa per determinare se contiene un valore intero.
+ [https://docs.aws.amazon.com/quicksight/latest/user/parseJson-function.html](https://docs.aws.amazon.com/quicksight/latest/user/parseJson-function.html) analizza i valori di un JSON nativo o un oggetto JSON in un campo di testo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/replace-function.html](https://docs.aws.amazon.com/quicksight/latest/user/replace-function.html) sostituisce parte di una stringa con una nuova stringa. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/right-function.html](https://docs.aws.amazon.com/quicksight/latest/user/right-function.html) restituisce il numero specificato di caratteri più a destra di una stringa.
+ [https://docs.aws.amazon.com/quicksight/latest/user/rtrim-function.html](https://docs.aws.amazon.com/quicksight/latest/user/rtrim-function.html) rimuove lo spazio vuoto successivo da una stringa.
+ [https://docs.aws.amazon.com/quicksight/latest/user/split-function.html](https://docs.aws.amazon.com/quicksight/latest/user/split-function.html) suddivide una stringa in un array di sottostringhe, in base a un delimitatore scelto, e restituisce la voce specificata dalla posizione. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/startsWith-function.html](https://docs.aws.amazon.com/quicksight/latest/user/startsWith-function.html) verifica se l'espressione inizia con la sottostringa specificata.
+ [https://docs.aws.amazon.com/quicksight/latest/user/strlen-function.html](https://docs.aws.amazon.com/quicksight/latest/user/strlen-function.html) restituisce il numero di caratteri di una stringa.
+ [https://docs.aws.amazon.com/quicksight/latest/user/substring-function.html](https://docs.aws.amazon.com/quicksight/latest/user/substring-function.html) restituisce il numero di caratteri specificato in una stringa, a partire dalla posizione specificata. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/toLower-function.html](https://docs.aws.amazon.com/quicksight/latest/user/toLower-function.html) formatta una stringa in tutte lettere minuscole.
+ [https://docs.aws.amazon.com/quicksight/latest/user/toString-function.html](https://docs.aws.amazon.com/quicksight/latest/user/toString-function.html) formatta l'espressione di input come stringa.
+ [https://docs.aws.amazon.com/quicksight/latest/user/toUpper-function.html](https://docs.aws.amazon.com/quicksight/latest/user/toUpper-function.html) formatta una stringa in tutte lettere maiuscole.
+ [https://docs.aws.amazon.com/quicksight/latest/user/trim-function.html](https://docs.aws.amazon.com/quicksight/latest/user/trim-function.html) rimuove sia lo spazio vuoto precedente che quello successivo da una stringa.

## Calcoli delle tabelle
<a name="table-calculations"></a>

I calcoli delle tabelle sono un gruppo di funzioni che offrono contesto in un'analisi e supporto per le analisi aggregate arricchite. Grazie a questi calcoli, puoi risolvere scenari aziendali comuni come il calcolo della percentuale di un totale, il calcolo di una somma in esecuzione, di una differenza, di una baseline comune e di una classificazione. 

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. 

**Funzioni basate sulla ricerca**
+ [https://docs.aws.amazon.com/quicksight/latest/user/difference-function.html](https://docs.aws.amazon.com/quicksight/latest/user/difference-function.html) calcola la differenza tra una misura basata su un set di partizioni e ordinamenti e una misura basata su un'altra. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/lag-function.html](https://docs.aws.amazon.com/quicksight/latest/user/lag-function.html) calcola il valore di ritardo (precedente) di una misura. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/lead-function.html](https://docs.aws.amazon.com/quicksight/latest/user/lead-function.html) calcola il valore di apertura (seguente) di una misura. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentDifference-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentDifference-function.html) calcola la differenza in percentuale tra il valore corrente e un valore di confronto.

**Funzioni Over**
+ [https://docs.aws.amazon.com/quicksight/latest/user/avgOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/avgOver-function.html) calcola la media di una misura su una o più dimensioni.
+ [https://docs.aws.amazon.com/quicksight/latest/user/countOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/countOver-function.html) calcola il conteggio di un campo su una o più dimensioni.
+ [https://docs.aws.amazon.com/quicksight/latest/user/distinctCountOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/distinctCountOver-function.html) calcola il conteggio distinto dell'operando partizionato dagli attributi specificati a un livello specificato. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/maxOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/maxOver-function.html) calcola il massimo di una misura su una o più dimensioni. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/minOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/minOver-function.html) calcola il valore minimo di una misura su una o più dimensioni. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileOver-function.html) (alias di `percentileDiscOver`) calcola l'*n* percentile di una misura divisa per un elenco di dimensioni. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html) calcola l'*n*-esimo percentile basato sulla distribuzione continua dei numeri di una misura divisa per un elenco di dimensioni.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html) calcola l'*n*-esimo percentile basato sui numeri correnti di una misura divisa per un elenco di dimensioni. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentOfTotal-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentOfTotal-function.html) calcola la percentuale in cui una misura contribuisce al totale. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodDifference-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodDifference-function.html) calcola la differenza di una misura su due periodi di tempo diversi, come specificato dalla granularità e dall'offset del periodo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodLastValue-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodLastValue-function.html) calcola l'ultimo valore (precedente) di una misura di un periodo di tempo precedente, come specificato dalla granularità e dall'offset del periodo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodPercentDifference-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodPercentDifference-function.html) calcola la differenza in percentuale di una misura su due periodi di tempo diversi, come specificato dalla granularità e dall'offset del periodo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateAvgOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateAvgOverTime-function.html) calcola la media di una misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateCountOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateCountOverTime-function.html) calcola il conteggio di una dimensione o misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMaxOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMaxOverTime-function.html) calcola il massimo di una misura o data specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMinOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMinOverTime-function.html) calcola il minimo di una misura o data specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateSumOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateSumOverTime-function.html) calcola la somma di una misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/sumOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sumOver-function.html) calcola la somma di una misura su una o più dimensioni. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevOver-function.html) calcola la deviazione standard della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a un campione.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevpOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevpOver-function.html) calcola la deviazione standard della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a una popolazione parziale.
+ [https://docs.aws.amazon.com/quicksight/latest/user/varOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varOver-function.html) calcola la varianza della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a un campione. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/varpOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varpOver-function.html) calcola la varianza della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a una popolazione parziale. 

**Funzioni di classificazione**
+ [https://docs.aws.amazon.com/quicksight/latest/user/rank-function.html](https://docs.aws.amazon.com/quicksight/latest/user/rank-function.html) calcola la classificazione di una misura o una dimensione.
+ [https://docs.aws.amazon.com/quicksight/latest/user/denseRank-function.html](https://docs.aws.amazon.com/quicksight/latest/user/denseRank-function.html) calcola la classificazione di una misura o una dimensione, ignorando i duplicati.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileRank-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileRank-function.html) calcola la classificazione di una misura o una dimensione in base al percentile.

**Funzioni in esecuzione**
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningAvg-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningAvg-function.html) calcola una media mobile per una misura.
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningCount-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningCount-function.html) calcola un conteggio corrente per una misura.
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningMax-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningMax-function.html) calcola un valore massimo corrente per una misura.
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningMin-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningMin-function.html) calcola un valore minimo corrente per una misura.
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningSum-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningSum-function.html) calcola una somma in esecuzione per una misura. 

**Funzioni finestra**
+ [https://docs.aws.amazon.com/quicksight/latest/user/firstValue-function.html](https://docs.aws.amazon.com/quicksight/latest/user/firstValue-function.html) calcola il primo valore della dimensione o della misura aggregata divisa e ordinata in base agli attributi specificati. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/lastValue-function.html](https://docs.aws.amazon.com/quicksight/latest/user/lastValue-function.html) calcola l'ultimo valore della dimensione o della misura aggregata divisa e ordinata in base agli attributi specificati. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowAvg-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowAvg-function.html) calcola la media della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati.
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowCount-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowCount-function.html) calcola il conteggio della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati.
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowMax-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowMax-function.html) calcola il valore massimo della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati.
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowMin-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowMin-function.html) calcola il valore minimo della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati.
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowSum-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowSum-function.html) calcola la somma della misura aggregata in una finestra personalizzata divisa e ordinata in base agli attributi specificati.

# Funzioni
<a name="functions"></a>

In questa sezione, puoi trovare un elenco di funzioni disponibili in Amazon Quick. Per visualizzare un elenco di funzioni ordinate per categoria, con brevi definizioni, consulta [Funzioni per categoria](https://docs.aws.amazon.com/quicksight/latest/user/functions-by-category.html).

**Topics**
+ [addDateTime](addDateTime-function.md)
+ [addWorkDays](addWorkDays-function.md)
+ [Abs](abs-function.md)
+ [Ceil](ceil-function.md)
+ [Coalesce](coalesce-function.md)
+ [Concat](concat-function.md)
+ [contains](contains-function.md)
+ [decimalToInt](decimalToInt-function.md)
+ [dateDiff](dateDiff-function.md)
+ [endsWith](endsWith-function.md)
+ [epochDate](epochDate-function.md)
+ [Exp](exp-function.md)
+ [Extract](extract-function.md)
+ [Floor](floor-function.md)
+ [formatDate](formatDate-function.md)
+ [Ifelse](ifelse-function.md)
+ [in](in-function.md)
+ [intToDecimal](intToDecimal-function.md)
+ [isNotNull](isNotNull-function.md)
+ [isNull](isNull-function.md)
+ [isWorkDay](isWorkDay-function.md)
+ [Left](left-function.md)
+ [Locate](locate-function.md)
+ [Log](log-function.md)
+ [Ln](ln-function.md)
+ [Ltrim](ltrim-function.md)
+ [Mod](mod-function.md)
+ [netWorkDays](netWorkDays-function.md)
+ [Now](now-function.md)
+ [notIn](notIn-function.md)
+ [nullIf](nullIf-function.md)
+ [parseDate](parseDate-function.md)
+ [parseDecimal](parseDecimal-function.md)
+ [parseInt](parseInt-function.md)
+ [parseJson](parseJson-function.md)
+ [Replace](replace-function.md)
+ [Right](right-function.md)
+ [Round](round-function.md)
+ [Rtrim](rtrim-function.md)
+ [Split](split-function.md)
+ [Sqrt](sqrt-function.md)
+ [startsWith](startsWith-function.md)
+ [Strlen](strlen-function.md)
+ [Substring](substring-function.md)
+ [switch](switch-function.md)
+ [toLower](toLower-function.md)
+ [toString](toString-function.md)
+ [toUpper](toUpper-function.md)
+ [trim](trim-function.md)
+ [truncDate](truncDate-function.md)

# addDateTime
<a name="addDateTime-function"></a>

`addDateTime` aggiunge o sottrae un'unità di tempo a o da un valore datetime. Ad esempio, `addDateTime(2,'YYYY',parseDate('02-JUL-2018', 'dd-MMM-yyyy') )` restituisce `02-JUL-2020`. È possibile utilizzare questa funzione per eseguire la matematica delle date sui dati di data e ora. 

## Sintassi
<a name="addDateTime-function-syntax"></a>

```
addDateTime(amount, period, datetime)
```

## Arguments (Argomenti)
<a name="addDateTime-function-arguments"></a>

 *amount*   
Un valore intero positivo o negativo che rappresenta la quantità di tempo che si desidera aggiungere o sottrarre dal campo di datetime fornito. 

 *punto*   
Un valore positivo o negativo che rappresenta la quantità di tempo che si desidera aggiungere o sottrarre dal campo di datetime fornito. I periodi validi sono:   
+ YYYY: restituisce la porzione dell'anno della data. 
+ Q: restituisce il trimestre di cui fa parte la data (1-4). 
+ MM: restituisce la porzione del mese della data. 
+ DD: restituisce la porzione del giorno della data. 
+ WK: restituisce la porzione della settimana della data. La settimana inizia di domenica in Amazon Quick. 
+ HH: restituisce la porzione dell'ora della data. 
+ MI: restituisce la porzione dei minuti della data. 
+ SS: restituisce la porzione dei secondi della data
+ MS: restituisce la porzione dei millisecondi della data.

 *datetime*   
La data o l'ora su cui si desidera eseguire la matematica delle date. 

## Tipo restituito
<a name="addDateTime-function-return-type"></a>

Datetime

## Esempio
<a name="addDateTime-function-example"></a>

Supponiamo di disporre di un campo denominato `purchase_date` che ha i seguenti valori.

```
2018 May 13 13:24
2017 Jan 31 23:06
2016 Dec 28 06:45
```

Utilizzando i seguenti calcoli, `addDateTime` modifica i valori come mostrato di seguito.

```
addDateTime(-2, 'YYYY', purchaseDate)

2016 May 13 13:24
2015 Jan 31 23:06
2014 Dec 28 06:45


addDateTime(4, 'DD', purchaseDate)

2018 May 17 13:24
2017 Feb 4 23:06
2017 Jan 1 06:45


addDateTime(20, 'MI', purchaseDate)

2018 May 13 13:44
2017 Jan 31 23:26
2016 Dec 28 07:05
```

# addWorkDays
<a name="addWorkDays-function"></a>

`addWorkDays` aggiunge o sottrae un determinato numero di giorni lavorativi a un determinato valore di data. La funzione restituisce una data per un giorno lavorativo, che corrisponde a un determinato giorno lavorativo dopo o prima di un determinato valore di data di input. 

## Sintassi
<a name="addWorkDays-function-syntax"></a>

```
addWorkDays(initDate, numWorkDays)
```

## Arguments (Argomenti)
<a name="addWorkDays-function-arguments"></a>

*initDate*  
Una data valida non NULL che funge da data di inizio del calcolo.   
+ **Campo del set di dati**: qualsiasi campo `date` del set di dati a cui si sta aggiungendo questa funzione.
+ **Funzione Data**: qualsiasi data emessa da un'altra funzione `date`, ad esempio `parseDate`, `epochDate`, `addDateTime` e così via.  
**Example**  

  ```
  addWorkDays(epochDate(1659484800), numWorkDays)
  ```
+ **Campi calcolati**: qualsiasi campo calcolato rapidamente che restituisce un `date` valore.  
**Example**  

  ```
  calcFieldStartDate = addDateTime(10, “DD”, startDate)
  addWorkDays(calcFieldStartDate, numWorkDays)
  ```
+ **Parametri**: qualsiasi `datetime` parametro Quick.  
**Example**  

  ```
  addWorkDays($paramStartDate, numWorkDays)
  ```
+ Qualsiasi combinazione dei valori degli argomenti sopra indicati.

 *numWorkDays*   
Una data valida non NULL che funge da data di fine del calcolo.   
+ **Letterale**: un valore letterale intero digitato direttamente nell'editor delle espressioni.  
**Example**  

  ```
  ```
+ **Campo del set di dati**: qualsiasi campo di data del set di dati   
**Example**  

  ```
  ```
+ **Funzione o calcolo scalare**: qualsiasi funzione scalare Quick che restituisce un output intero da un'altra, ad esempio `decimalToInt``abs`, e così via.  
**Example**  

  ```
  addWorkDays(initDate, decimalToInt(sqrt (abs(numWorkDays)) ) )
  ```
+ **Campo calcolato: qualsiasi campo** calcolato in modo rapido che restituisce un valore. `date`  
**Example**  

  ```
  someOtherIntegerCalcField = (num_days * 2) + 12
  addWorkDays(initDate, someOtherIntegerCalcField)
  ```
+ **Parametro**: qualsiasi `datetime` parametro Quick.  
**Example**  

  ```
  addWorkDays(initDate, $param_numWorkDays)
  ```
+ Qualsiasi combinazione dei valori degli argomenti sopra indicati.

## Tipo restituito
<a name="addWorkDays-function-return-type"></a>

Numero intero 

## Valori di output
<a name="addWorkDays-function-output-type"></a>

I valori di output previsti includono:
+ Numero intero positivo (quando start\$1date < end\$1date)
+ Numero intero negativo (quando start\$1date > end\$1date)
+ NULL quando uno o entrambi gli argomenti ottengono un valore nullo dal `dataset field`.

## Errori di input
<a name="addWorkDays-function-errors"></a>

I valori degli argomenti non consentiti causano errori, come illustrato negli esempi seguenti.
+ L'utilizzo di un valore letterale NULL come argomento nell'espressione non è consentito.  
**Example**  

  ```
  addWorkDays(NULL, numWorkDays) 
  ```  
**Example**  

  ```
  Error
  At least one of the arguments in this function does not have correct type. 
  Correct the expression and choose Create again.
  ```
+ L'utilizzo di una stringa letterale come argomento o di qualsiasi altro tipo di dati diverso dalla data nell'espressione non è consentito. Nell'esempio seguente, la stringa **"2022-08-10"** ha l'aspetto di una data, ma in realtà è una stringa. Per utilizzarla, è necessario utilizzare una funzione che converta in un tipo di dati di data.  
**Example**  

  ```
  addWorkDays("2022-08-10", 10)
  ```  
**Example**  

  ```
  Error
  Expression addWorkDays("2022-08-10", numWorkDays) for function addWorkDays has 
  incorrect argument type addWorkDays(String, Number). 
  Function syntax expects Date, Integer.
  ```

## Esempio
<a name="addWorkDays-function-example"></a>

Un numero intero positivo come l'argomento `numWorkDays` produrrà una data futura della data di input. Un numero intero negativo come l'argomento `numWorkDays` produrrà una data risultante successiva alla data di input. Un valore zero per l'argomento `numWorkDays` restituisce lo stesso valore della data di input indipendentemente dal fatto che ricada in un giorno lavorativo o in un fine settimana.

La funzione `addWorkDays` funziona con la granularità: `DAY`. La precisione non può essere preservata con alcuna granularità inferiore o superiore al livello `DAY`.

```
addWorkDays(startDate, endDate)
```

Supponiamo che esista un campo denominato `employmentStartDate` con i seguenti valori: 

```
2022-08-10 2022-08-06 2022-08-07 
```

Utilizzando il campo precedente e i seguenti calcoli, `addWorkDays` restituisce i valori modificati come illustrato di seguito:

```
addWorkDays(employmentStartDate, 7)

2022-08-19 
2022-08-16 
2022-08-16 

addWorkDays(employmentStartDate, -5)

2022-08-02 
2022-08-01 
2022-08-03 

addWorkDays(employmentStartDate, 0)

2022-08-10 
2022-08-06 
2022-08-07
```

L'esempio seguente calcola il bonus totale proporzionale da versare a ciascun dipendente per 2 anni in base al numero di giorni effettivamente lavorati da ciascun dipendente.

```
last_day_of_work = addWorkDays(employment_start_date, 730)
total_days_worked = netWorkDays(employment_start_date, last_day_of_work)
total_bonus = total_days_worked * bonus_per_day
```

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/addWorkDays-function-example.png)


# Abs
<a name="abs-function"></a>

`abs` restituisce il valore assoluto di una determinata espressione. 

## Sintassi
<a name="abs-function-syntax"></a>

```
abs(expression)
```

## Arguments (Argomenti)
<a name="abs-function-arguments"></a>

 *espressione*   
L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. 

# Ceil
<a name="ceil-function"></a>

`ceil` arrotonda un valore decimale al successivo intero più alto Ad esempio, `ceil(29.02)` restituisce `30`.

## Sintassi
<a name="ceil-function-syntax"></a>

```
ceil(decimal)
```

## Arguments (Argomenti)
<a name="ceil-function-arguments"></a>

 *decimale*   
Campo che utilizza il tipo di dati decimale, un valore letterale come **17.62** o una chiamata a un'altra funzione che genera un decimale.

## Tipo restituito
<a name="ceil-function-return-type"></a>

Numero intero

## Esempio
<a name="ceil-function-example"></a>

L'esempio seguente arrotonda un campo di valori decimali al successivo intero più alto.

```
ceil(salesAmount)
```

I seguenti sono i valori di campo forniti.

```
20.13
892.03
57.54
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
21
893
58
```

# Coalesce
<a name="coalesce-function"></a>

`coalesce` restituisce il valore del primo argomento che non è null. Quando viene trovato un valore non null, gli argomenti rimanenti nell'elenco non vengono valutati. Se tutti gli argomenti sono null, il risultato è null. Le stringhe con lunghezza pari a 0 sono valori validi e non sono considerate equivalenti a null.

## Sintassi
<a name="coalesce-function-syntax"></a>

```
coalesce(expression1, expression2 [, expression3, ...])
```

## Arguments (Argomenti)
<a name="coalesce-function-arguments"></a>

`coalesce` richiede due o più espressioni come argomenti. Tutte le espressioni devono avere lo stesso tipo di dati o essere in grado di eseguire implicitamente il cast per lo stesso tipo di dati.

 *espressione*   
L'espressione può essere numerica, datetime o stringa. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. 

## Tipo restituito
<a name="coalesce-function-return-type"></a>

`coalesce` restituisce un valore dello stesso tipo di dati degli argomenti di input.

## Esempio
<a name="coalesce-function-example"></a>

L'esempio seguente recupera l'indirizzo di fatturazione di un cliente, se esistente, il suo indirizzo postale se non vi è alcun indirizzo di fatturazione oppure restituisce "No address listed" (Nessun indirizzo elencato) se non è disponibile alcun indirizzo.

```
coalesce(billingAddress, streetAddress, 'No address listed')
```

# Concat
<a name="concat-function"></a>

`concat` concatena due o più stringhe.

## Sintassi
<a name="concat-function-syntax"></a>

```
concat(expression1, expression2 [, expression3 ...])
```

## Arguments (Argomenti)
<a name="concat-function-arguments"></a>

`concat` richiede due o più espressioni stringa come argomenti. 

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

## Tipo restituito
<a name="concat-function-return-type"></a>

Stringa

## Esempi
<a name="concat-function-example"></a>

L'esempio seguente concatena tre campi stringa e aggiunge la spaziatura appropriata.

```
concat(salutation, ' ', firstName, ' ', lastName)
```

I seguenti sono i valori di campo forniti.

```
salutation     firstName          lastName
-------------------------------------------------------
Ms.            Li                  Juan
Dr.            Ana Carolina        Silva
Mr.            Nikhil              Jayashankar
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
Ms. Li Juan
Dr. Ana Carolina Silva
Mr. Nikhil Jayashankar
```

L'esempio seguente concatena due letterali di stringa.

```
concat('Hello', 'world')
```

Viene restituito il valore seguente.

```
Helloworld
```

# contains
<a name="contains-function"></a>

`contains` valuta se la sottostringa specificata esiste all'interno di un'espressione. Se l'espressione inizia con la sottostringa, contains restituisce true, altrimenti restituisce false.

## Sintassi
<a name="contains-function-syntax"></a>

```
contains(expression, substring, string-comparison-mode)
```

## Arguments (Argomenti)
<a name="contains-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

 *sottostringa*   
Il set di caratteri da confrontare con l'*espressione*. La sottostringa può presentarsi una o più volte nell'*espressione*.

 *string-comparison-mode*   
(Facoltativo) Specifica la modalità di confronto delle stringhe da utilizzare:  
+ `CASE_SENSITIVE`: i confronti tra stringhe distinguono tra maiuscole e minuscole. 
+ `CASE_INSENSITIVE`: i confronti tra stringhe distinguono tra maiuscole e minuscole.
Per impostazione predefinita, questo valore è impostato su `CASE_SENSITIVE` quando è vuoto.

## Tipo restituito
<a name="contains-function-return-type"></a>

Booleano

## Esempi
<a name="contains-function-example"></a>

### Esempio predefinito che distingue tra maiuscole e minuscole
<a name="contains-function-example-default-case-sensitive"></a>

Il seguente esempio senza distinzione tra maiuscole e minuscole valuta se `state_nm` contiene **New**.

```
contains(state_nm, "New")
```

I seguenti sono i valori di campo forniti.

```
New York
new york
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
true
false
```

### Esempio senza distinzione tra maiuscole e minuscole
<a name="contains-function-example-case-insensitive"></a>

Il seguente esempio senza distinzione tra maiuscole e minuscole valuta se `state_nm` contiene **new**.

```
contains(state_nm, "new", CASE_INSENSITIVE)
```

I seguenti sono i valori di campo forniti.

```
New York
new york
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
true
true
```

### Esempio con istruzioni condizionali
<a name="contains-function-example-conditional-statements"></a>

La funzione contains può essere utilizzata come istruzione condizione all'interno delle seguenti funzioni If: [avgIf](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [minIf](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) e [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). 

Il seguente esempio somma `Sales` solo se `state_nm` contiene **New**.

```
sumIf(Sales,contains(state_nm, "New"))
```

### NON contiene esempi
<a name="contains-function-example-does-not-contain"></a>

L'operatore `NOT` condizionale può essere utilizzato per valutare se l'espressione non contiene con la sottostringa specificata. 

```
NOT(contains(state_nm, "New"))
```

### Esempio di utilizzo dei valori numerici
<a name="contains-function-example-numeric-values"></a>

I valori numerici possono essere utilizzati negli argomenti di espressioni o sottostringhe applicando la funzione `toString`.

```
contains(state_nm, toString(5) )
```

# decimalToInt
<a name="decimalToInt-function"></a>

`decimalToInt` converte un valore decimale in un tipo di dati intero eliminando la virgola decimale e ogni numero successivo. `decimalToInt` non effettua l'arrotondamento. Ad esempio, `decimalToInt(29.99)` restituisce `29`.

## Sintassi
<a name="decimalToInt-function-syntax"></a>

```
decimalToInt(decimal)
```

## Arguments (Argomenti)
<a name="decimalToInt-function-arguments"></a>

 *decimale*   
Campo che utilizza il tipo di dati decimale, un valore letterale come **17.62** o una chiamata a un'altra funzione che genera un decimale.

## Tipo restituito
<a name="decimalToInt-function-return-type"></a>

Numero intero

## Esempio
<a name="decimalToInt-function-example"></a>

L'esempio seguente converte un campo di valori decimali in un intero.

```
decimalToInt(salesAmount)
```

I seguenti sono i valori di campo forniti.

```
 20.13
892.03
 57.54
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
 20
892
 57
```

# dateDiff
<a name="dateDiff-function"></a>

`dateDiff` restituisce la differenza in giorni tra due campi della data Se si include un valore per il periodo, `dateDiff` restituisce la differenza nel periodo di intervallo, invece che in giorni.

## Sintassi
<a name="dateDiff-function-syntax"></a>

```
dateDiff(date1, date2,[period])
```

## Arguments (Argomenti)
<a name="dateDiff-function-arguments"></a>

`dateDiff` richiede due date come argomenti. Specificare un periodo è facoltativo.

 *data 1*   
La prima data nel confronto. Un campo data o una chiamata a un'altra funzione che genera una data. 

 *data 2*   
La seconda data nel confronto. Un campo data o una chiamata a un'altra funzione che genera una data. 

 *punto*   
Il periodo di differenza che si desidera ottenere, racchiuso tra virgolette. I periodi validi sono:  
+ YYYY: restituisce la porzione dell'anno della data.
+ Q: restituisce la data del primo giorno del trimestre al quale appartiene la data. 
+ MM: restituisce la porzione del mese della data.
+ DD: restituisce la porzione del giorno della data.
+ WK: restituisce la porzione della settimana della data. La settimana inizia di domenica in Amazon Quick.
+ HH: restituisce la porzione dell'ora della data.
+ MI: restituisce la porzione dei minuti della data.
+ SS: restituisce la porzione dei secondi della data
+ MS: restituisce la porzione dei millisecondi della data.

## Tipo restituito
<a name="dateDiff-function-return-type"></a>

Numero intero

## Esempio
<a name="dateDiff-function-example"></a>

L'esempio seguente restituisce la differenza tra due date.

```
dateDiff(orderDate, shipDate, "MM")
```

I seguenti sono i valori di campo forniti.

```
orderDate          shipdate
=============================
01/01/18            03/05/18
09/13/17            10/20/17
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
2
1
```

# endsWith
<a name="endsWith-function"></a>

`endsWith` valuta se l'espressione termina con una sottostringa specificata dall'utente. Se l'espressione termina con la sottostringa, `endsWith` restituisce true, altrimenti restituisce false.

## Sintassi
<a name="endsWith-function-syntax"></a>

```
endsWith(expression, substring, string-comparison-mode)
```

## Arguments (Argomenti)
<a name="endsWith-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

 *sottostringa*   
Il set di caratteri da confrontare con l'*espressione*. La sottostringa può presentarsi una o più volte nell'*espressione*.

 *string-comparison-mode*   
(Facoltativo) Specifica la modalità di confronto delle stringhe da utilizzare:  
+ `CASE_SENSITIVE`: i confronti tra stringhe distinguono tra maiuscole e minuscole. 
+ `CASE_INSENSITIVE`: i confronti tra stringhe distinguono tra maiuscole e minuscole.
Per impostazione predefinita, questo valore è impostato su `CASE_SENSITIVE` quando è vuoto.

## Tipo restituito
<a name="endsWith-function-return-type"></a>

Booleano

## Esempi
<a name="endsWith-function-example"></a>

### Esempio predefinito che distingue tra maiuscole e minuscole
<a name="endsWith-function-example-default-case-sensitive"></a>

Il seguente esempio con distinzione tra maiuscole e minuscole valuta se `state_nm` endsWith **"York"**.

```
endsWith(state_nm, "York")
```

I seguenti sono i valori di campo forniti.

```
New York
new york
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
true
false
```

### Esempio senza distinzione tra maiuscole e minuscole
<a name="endsWith-function-example-case-insensitive"></a>

Il seguente esempio senza distinzione tra maiuscole e minuscole valuta se `state_nm` endsWith **"york"**.

```
endsWith(state_nm, "york", CASE_INSENSITIVE)
```

I seguenti sono i valori di campo forniti.

```
New York
new york
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
true
true
```

### Esempio con istruzioni condizionali
<a name="endsWith-function-example-conditional-statements"></a>

La funzione `endsWith` può essere utilizzata come istruzione condizione all'interno delle seguenti funzioni If: [avgIf](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [minIf](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) e [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). 

Il seguente esempio somma `Sales` solo se `state_nm` termina con **"York"**.

```
sumIf(Sales,endsWith(state_nm, "York"))
```

### NON contiene esempi
<a name="endsWith-function-example-does-not-start-with"></a>

L'operatore `NOT` condizionale può essere utilizzato per valutare se l'espressione non inizia con la sottostringa specificata. 

```
NOT(endsWith(state_nm, "York"))
```

### Esempio di utilizzo dei valori numerici
<a name="endsWith-function-example-numeric-values"></a>

I valori numerici possono essere utilizzati negli argomenti di espressioni o sottostringhe applicando la funzione `toString`.

```
endsWith(state_nm, toString(5) )
```

# epochDate
<a name="epochDate-function"></a>

`epochDate`[converte la data di un'epoca in una data standard nel formato aaaa-MM-gg **T** kk:mm:ss.sss **Z**, utilizzando la sintassi del modello di formato specificata in Class nella documentazione del progetto Joda. DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) Un esempio è `2015-10-15T19:11:51.003Z`. 

`epochDate`è supportato per l'uso con analisi basate su SPICE set di dati archiviati in Quick ().

## Sintassi
<a name="epochDate-function-syntax"></a>

```
epochDate(epochdate)
```

## Arguments (Argomenti)
<a name="epochDate-function-arguments"></a>

 *data epoca*   
Una data epoca (Unix epoch), che è una rappresentazione di intero di una data come il numero di secondi dalle 00:00:00 UTC del 1° gennaio 1970.   
*data epoca* deve essere un intero. Può trattarsi del nome di un campo che utilizza il tipo di dati intero, un valore intero letterale o una chiamata a un'altra funzione che genera un intero. Se il valore intero contiene più di 10 cifre, le cifre dopo la decima posizione vengono ignorate.

## Tipo restituito
<a name="epochDate-function-return-type"></a>

Data

## Esempio
<a name="epochDate-function-example"></a>

L'esempio seguente converte una data epoca (Unix epoch) in una data standard.

```
epochDate(3100768000)
```

Viene restituito il valore seguente.

```
2068-04-04T12:26:40.000Z
```

# Exp
<a name="exp-function"></a>

`exp` restituisce la base del logaritmo naturale in base e elevato alla potenza di una determinata espressione. 

## Sintassi
<a name="exp-function-syntax"></a>

```
exp(expression)
```

## Arguments (Argomenti)
<a name="exp-function-arguments"></a>

 *espressione*   
L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. 

# Extract
<a name="extract-function"></a>

`extract` restituisce una parte specificata di un valore di data La richiesta di una porzione relativa all'ora di una data che non contiene informazioni sull'ora restituisce 0.

## Sintassi
<a name="extract-function-syntax"></a>

```
extract(period, date)
```

## Arguments (Argomenti)
<a name="extract-function-arguments"></a>

 *punto*   
Il periodo che si desidera estrarre dal valore della data. I periodi validi sono:  
+ YYYY: restituisce la porzione dell'anno della data.
+ Q: restituisce il trimestre di cui fa parte la data (1-4). 
+ MM: restituisce la porzione del mese della data.
+ DD: restituisce la porzione del giorno della data.
+ WD: restituisce il giorno della settimana come intero, con domenica come 1.
+ HH: restituisce la porzione dell'ora della data.
+ MI: restituisce la porzione dei minuti della data.
+ SS: restituisce la porzione dei secondi della data
+ MS: restituisce la porzione dei millisecondi della data.
**Nota**  
L'estrazione dei millisecondi non è supportata nei database Presto precedenti alla versione 0.216.

 *data*   
Un campo data o una chiamata a un'altra funzione che genera una data.

## Tipo restituito
<a name="extract-function-return-type"></a>

Numero intero

## Esempio
<a name="extract-function-example"></a>

L'esempio seguente estrae il giorno da un valore di data.

```
extract('DD', orderDate)
```

I seguenti sono i valori di campo forniti.

```
orderDate
=========
01/01/14  
09/13/16
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
01
13
```

# Floor
<a name="floor-function"></a>

`floor` riduce un valore decimale al successivo intero più basso Ad esempio, `floor(29.08)` restituisce `29`.

## Sintassi
<a name="floor-function-syntax"></a>

```
floor(decimal)
```

## Arguments (Argomenti)
<a name="floor-function-arguments"></a>

 *decimale*   
Campo che utilizza il tipo di dati decimale, un valore letterale come **17.62** o una chiamata a un'altra funzione che genera un decimale.

## Tipo restituito
<a name="floor-function-return-type"></a>

Numero intero

## Esempio
<a name="floor-function-example"></a>

L'esempio seguente riduce un campo di valori decimali al successivo intero più basso.

```
floor(salesAmount)
```

I seguenti sono i valori di campo forniti.

```
20.13
892.03
57.54
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
20
892
57
```

# formatDate
<a name="formatDate-function"></a>

`formatDate` formatta una data utilizzando un modello specificato. Quando si preparano i dati, è possibile utilizzare `formatDate` per riformattare la data. Per riformattare una data in un'analisi, scegli l'opzione di formato dal menu contestuale del campo data.

## Sintassi
<a name="formatDate-function-syntax"></a>

```
formatDate(date, ['format'])
```

## Arguments (Argomenti)
<a name="formatDate-function-arguments"></a>

 *data*   
Un campo data o una chiamata a un'altra funzione che genera una data.

 *format*   
(Facoltativo) Stringa contenente il modello del formato da applicare. Questo argomento accetta i modelli di formato specificati in [Formati di data supportati](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html).  
Se non si specifica un formato, per impostazione predefinita questa stringa viene impostata su yyyy-MM-dd**T**kk:mm:ss:SSS.

## Tipo restituito
<a name="formatDate-function-return-type"></a>

Stringa

## Esempio
<a name="formatDate-function-example"></a>

L'esempio seguente formatta una data UTC.

```
formatDate(orderDate, 'dd-MMM-yyyy')
```

I seguenti sono i valori di campo forniti.

```
order date      
=========
2012-12-14T00:00:00.000Z  
2013-12-29T00:00:00.000Z
2012-11-15T00:00:00.000Z
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
13 Dec 2012
28 Dec 2013
14 Nov 2012
```

## Esempio
<a name="formatDate-function-example2"></a>

Se la data contiene virgolette singole o apostrofi, ad esempio `yyyyMMdd'T'HHmmss`, puoi gestire questo formato di data utilizzando uno dei seguenti metodi.
+ Racchiudi l'intera data tra virgolette doppie, come illustrato nell'esempio seguente:

  ```
  formatDate({myDateField}, "yyyyMMdd'T'HHmmss")
  ```
+ Evita le virgolette o gli apostrofi aggiungendo una barra rovesciata (`\`) alla loro sinistra, come illustrato nell'esempio seguente: 

  ```
  formatDate({myDateField}, 'yyyyMMdd\'T\'HHmmss')
  ```

# Ifelse
<a name="ifelse-function"></a>

`ifelse` valuta un set di *se*, gli abbinamenti delle espressioni *poi* e restituisce il valore dell'argomento *poi* per il primo argomento *se* che valuta come true. Se nessuno degli argomenti *se* viene valutato come true, viene restituito il valore dell'argomento *altro*.

## Sintassi
<a name="ifelse-function-syntax"></a>

```
ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression)
```

## Arguments (Argomenti)
<a name="ifelse-function-arguments"></a>

`ifelse` richiede uno o più abbinamenti di espressioni *if*,*then* e una espressione per l'argomento *else*. 

 *espressione if*   
L'espressione da valutare come true o meno. Può trattarsi di un nome di campo come **address1**, un valore letterale come **'Unknown'** o un'altra funzione come `toString(salesAmount)`. Un esempio è `isNotNull(FieldName)`.   
Se si utilizzano più operatori AND e OR nell'argomento `if`, racchiudere le istruzioni tra parentesi per individuare l'ordine di elaborazione. Ad esempio, il seguente argomento `if` restituisce record con un mese 1, 2 o 5 e un anno 2000.  

```
ifelse((month = 5 OR month < 3) AND year = 2000, 'yes', 'no')
```
Il successivo argomento `if` utilizza gli stessi operatori, ma restituisce record con un mese 5 e un anno qualsiasi oppure con un mese 1 o 2 e un anno 2000.  

```
ifelse(month = 5 OR (month < 3 AND year = 2000), 'yes', 'no')
```

 *then-expression*   
L'espressione da restituire se il relativo l'argomento *se* viene valutato come true. Può trattarsi di un nome di campo come **address1**, un valore letterale come **'Unknown'** o una chiamata a un'altra funzione. L'espressione deve avere lo stesso tipo di dati degli altri argomenti `then` e dell'argomento `else`. 

 *else-expression*   
L'espressione da restituire se nessuno degli argomenti *se* viene valutato come true. Può trattarsi di un nome di campo come **address1**, un valore letterale come **'Unknown'** o un'altra funzione come `toString(salesAmount)`. L'espressione deve avere lo stesso tipo di dati di tutti gli argomenti `then`. 

## Tipo restituito
<a name="ifelse-function-return-type"></a>

`ifelse` restituisce un valore dello stesso tipo di dati dei valori in *then-expression*. Tutti i dati restituiti da *then* e *else* devono essere dello stesso tipo o essere convertiti nello stesso tipo. 

## Esempi
<a name="ifelse-function-example"></a>

L'esempio seguente genera una colonna di alias per il campo `country`.

```
ifelse(country = "United States", "US", country = "China", "CN", country = "India", "IN", "Others") 
```

In questi casi d'uso che valutano ogni valore di un campo rispetto a un elenco di valori letterali e restituiscono il risultato corrispondente al primo valore corrispondente, si consiglia di utilizzare la funzione switch per semplificare il lavoro. L'esempio precedente può essere riscritto nella seguente dichiarazione utilizzando [https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html](https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html):

```
switch(country,"United States","US","China","CN","India","IN","Others")
```

L'esempio seguente classifica le vendite per cliente in livelli leggibili dall'uomo.

```
ifelse(salesPerCustomer < 1000, “VERY_LOW”, salesPerCustomer < 10000, “LOW”, salesPerCustomer < 100000, “MEDIUM”, “HIGH”)
```

L'esempio seguente utilizza AND, OR e NOT per confrontare più espressioni utilizzando operatori condizionali per applicare tag ai clienti principali NON (NOT) a Washington o in Oregon con una promozione speciale che hanno effettuato più di 10 ordini. Se non viene restituito alcun valore, viene utilizzato il valore `'n/a'`.

```
ifelse(( (NOT (State = 'WA' OR State =  'OR')) AND Orders > 10),  'Special Promotion XYZ',  'n/a')
```

Gli esempi seguenti utilizzano solo OR per generare una nuova colonna che contiene il nome del continente corrispondente a ciascun `country`.

```
ifelse(country = "United States" OR country = "Canada", "North America", country = "China" OR country = "India" OR country = "Japan", "Asia", "Others")
```

L'esempio precedente può essere semplificato come illustrato nell'esempio successivo. L'esempio seguente utilizza `ifelse` e [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) per creare un valore in una nuova colonna per ogni riga in cui il valore testato si trova in un elenco di letterali. Puoi usare `ifelse` anche con [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html).

```
ifelse(in(country,["United States", "Canada"]), "North America", in(country,["China","Japan","India"]),"Asia","Others")
```

Gli autori possono salvare un elenco di letterali in un parametro multi-valore e utilizzarlo nelle funzioni [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) o [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html). L'esempio seguente è un equivalente dell'esempio precedente, tranne per il fatto che gli elenchi di letterali sono memorizzati in due parametri multi-valore. 

```
ifelse(in(country,${NorthAmericaCountryParam}), "North America", in(country,${AsiaCountryParam}),"Asia", "Others") 
```

L'esempio seguente assegna un gruppo a un record delle vendite basato sul totale delle vendite. La struttura di ogni frase `if-then` imita il comportamento dell'operatore *tra*, una parola chiave che attualmente non funziona nelle espressioni di campi calcolati. Ad esempio, il risultato del confronto `salesTotal >= 0 AND salesTotal < 500` restituisce gli stessi valori del confronto `salesTotal between 0 and 499` SQL.

```
ifelse(salesTotal >= 0 AND salesTotal < 500, 'Group 1', salesTotal >= 500 AND salesTotal < 1000, 'Group 2', 'Group 3')
```

L'esempio seguente verifica la presenza di un valore NULL utilizzando `coalesce` per restituire il primo valore non NULL. Invece di dover ricordare il significato di un valore NULL in un campo di data, è possibile utilizzare una descrizione leggibile. Se la data di disconnessione è NULL, l'esempio restituisce la data di sospensione, a meno che entrambe non siano NULL. Quindi `coalesce(DiscoDate, SuspendDate, '12/31/2491')` restituisce `'12/31/2491'`. Il valore restituito deve corrispondere agli altri tipi di dati. Questa data potrebbe sembrare un valore insolito, ma una data del 25° secolo simula ragionevolmente la "fine dei tempi", definita come la data più alta in un data mart. 

```
ifelse (  (coalesce(DiscoDate, SuspendDate, '12/31/2491') = '12/31/2491'),  'Active subscriber', 'Inactive subscriber')
```

Di seguito viene illustrato un esempio più complesso in un formato più leggibile, solo per dimostrare che non è necessario comprimere tutto il codice in un'unica lunga riga. Questo esempio fornisce confronti multipli del valore di un risultato dell'indagine. Gestisce i potenziali valori NULL per questo campo e classifica due intervalli accettabili. Inoltre etichetta un intervallo che richiede più test e un altro non valido (fuori intervallo). Per tutti i valori rimanenti, applica la condizione `else` ed etichetta la riga come se fosse necessario ripetere il test tre anni dopo la data in quella riga. 

```
ifelse
( 
    isNull({SurveyResult}), 'Untested',  
    {SurveyResult}=1, 'Range 1', 
    {SurveyResult}=2, 'Range 2', 
    {SurveyResult}=3, 'Need more testing',
    {SurveyResult}=99, 'Out of Range',
    concat  
    (
        'Retest by ', 
        toString    
        (
           addDateTime(3, "YYYY", {Date}) 
        )
    )
)
```

L'esempio seguente assegna un nome di regione creato "manualmente" a un gruppo di stati. Utilizza inoltre spaziatura e commenti, integrati `/* */`, per semplificare la manutenzione del codice. 

```
ifelse 
(    /* NE REGION*/
     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
    'Northeast',

     /* SE REGION*/
     locate('Georgia, Alabama, South Carolina, Louisiana',{State}) > 0,
    'Southeast',

    'Other Region'
)
```

La logica per l'etichettatura delle regioni si suddivide come segue:

1. Elenchiamo gli stati che vogliamo per ogni regione, racchiudendo ogni elenco tra virgolette per trasformare ogni elenco in una stringa, come riportato di seguito: 
   + `'New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire'`
   + `'Georgia, Alabama, South Carolina, Louisiana'`
   + Puoi aggiungere altri set o utilizzare paesi, città, province o What3Words, se lo desideri. 

1. Chiediamo se il valore per `State` (per ogni riga) si trova nell'elenco, utilizzando la funzione `locate` per restituire un valore diverso da zero se lo stato si trova nell'elenco, come riportato di seguito.

   ```
   locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) 
   
   and
   
   locate('Georgia, Alabama, South Carolina, Louisiana',{State})
   ```

1. La funzione `locate` restituisce un numero anziché un `TRUE` o `FALSE`, ma `ifelse` richiede il valore booleano `TRUE`/`FALSE`. Per ovviare a questo problema, possiamo confrontare il risultato di `locate` con un numero. Se lo stato è presente nell'elenco, il valore restituito è maggiore di zero.

   1. Chiedi se lo stato è presente.

      ```
      locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0
      ```

   1. Se è presente la regione, etichettala come regione specifica, in questo caso regione nord-orientale.

      ```
      /*The if expression:*/     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
      /*The then expression:*/   'Northeast',
      ```

1. Poiché abbiamo stati che non sono in un elenco e poiché `ifelse` richiede una singola espressione `else`, forniamo `'Other Region'` come etichetta per gli stati rimanenti. 

   ```
   /*The if expression:*/     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
   /*The then expression:*/   'Northeast',
   /*The else expression:*/   'Other Region'
   ```

1. Tutto questo lo racchiudiamo nella funzione `ifelse( )` per ottenere la versione finale. L'esempio seguente esclude gli stati della regione sud-orientale presenti nell'originale. Puoi aggiungerli nuovamente al posto del tag *`<insert more regions here>`*. 

   Se desideri aggiungere altre regioni, puoi creare più copie di queste due righe e modificare l'elenco degli stati in base alle tue esigenze. Puoi cambiare il nome della regione in base alle tue esigenze e cambiare il nome del campo da `State` in qualsiasi cosa ti serva. 

   ```
   ifelse 
   (
   /*The if expression:*/     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
   /*The then expression:*/   'Northeast',
   
   /*<insert more regions here>*/
   
   /*The else expression:*/   'Other Region'
   )
   ```
**Nota**  
Esistono altri modi per eseguire il confronto iniziale per l'espressione if. Ad esempio, supponiamo di porre la domanda "Quali stati non mancano in questo elenco?" anziché "Quali stati sono presenti nell'elenco?" Se lo fai, potresti formularla in modo diverso. È possibile confrontare l'istruzione locate con zero per trovare i valori mancanti nell'elenco e quindi utilizzare l'operatore NOT per classificarli come "non mancanti", come riportato di seguito.  

   ```
   /*The if expression:*/      NOT (locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) = 0),
   ```
Entrambe le versioni sono corrette. La versione che scegli dovrebbe avere più senso per te e per il tuo team, in modo da poterla gestire facilmente. Se tutte le opzioni sembrano uguali, scegli la più semplice.

# in
<a name="in-function"></a>

`in` valuta se un'espressione esiste all'interno di un elenco di letterali. Se l'elenco non contiene l'espressione, in restituisce true, altrimenti restituisce false. `in` fa distinzione tra maiuscole e minuscole per gli input di tipo stringa.

`in` accetta due tipi di elenco di letterali, uno è un elenco inserito manualmente e l'altro è un [parametro multi-valore](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html).

## Sintassi
<a name="in-function-syntax"></a>

Utilizzando un elenco inserito manualmente:

```
in(expression, [literal-1, ...])  
```

Utilizzando un parametro multi-valore:

```
in(expression, $multivalue_parameter)
```

## Arguments (Argomenti)
<a name="in-function-arguments"></a>

 *espressione*   
L'espressione da confrontare con gli elementi dell'elenco di letterali. Può essere un nome di campo come `address`, un valore letterale come '**Unknown**', un parametro a valore singolo o una chiamata a un'altra funzione scalare, purché questa funzione non sia una funzione aggregata o un calcolo di tabella.

 *elenco di letterali*   
(obbligatorio) Può trattarsi di un elenco inserito manualmente o di un parametro multi-valore. Questo argomento accetta fino a 5.000 elementi. Tuttavia, in una query diretta a un'origine dati di terze parti, ad esempio Oracle o Teradata, la restrizione può essere minore.  
+ ***elenco inserito manualmente***: uno o più valori letterali in un elenco da confrontare con l'espressione. L'elenco deve essere racchiuso tra parentesi quadrate. Tutti i valori letterali da confrontare devono avere lo stesso tipo di dati dell'espressione. 
+ ***parametro multi-valore***: un parametro multivalore predefinito passato come elenco di letterali. Il parametro multi-valore deve avere lo stesso tipo di dati dell'espressione. 


## Tipo restituito
<a name="in-function-return-type"></a>

Valore booleano: TRUE/FALSE

## Esempio con un elenco statico
<a name="in-function-example-static-list"></a>

L'esempio seguente valuta il campo `origin_state_name` per i valori in un elenco di stringhe. Quando si confrontano input di tipo di stringa, `in` supporta solo il confronto con distinzione tra maiuscole e minuscole

```
in(origin_state_name,["Georgia", "Ohio", "Texas"])
```

I seguenti sono i valori di campo forniti.

```
"Washington"
        "ohio"
        "Texas"
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
false
        false
        true
```

Il terzo valore restituito è true in quanto solo "Texas" è uno dei valori inclusi.

L'esempio seguente valuta il campo `fl_date` per i valori in un elenco di stringhe. Per far corrispondere il tipo, `toString` viene utilizzato per convertire il tipo di data in un tipo di stringa.

```
in(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"])
```

![\[Un'immagine dei risultati dell'esempio della funzione, sotto forma di tabella.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/in-function-example-manual-list.png)


I valori letterali e NULL sono supportati nell'argomento dell'espressione da confrontare con i valori letterali nell'elenco. Entrambi i due esempi seguenti genereranno una nuova colonna di valori TRUE. 

```
in("Washington",["Washington","Ohio"])
```

```
in(NULL,[NULL,"Ohio"])
```

## Esempio con parametro multi-valore
<a name="in-function-example-mutivalue-parameter"></a>

Supponiamo che un autore crei un [parametro multi-valore](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) che contiene un elenco di tutti i nomi degli stati. Quindi l'autore aggiunge un controllo per consentire al lettore di selezionare i valori dall'elenco.

Successivamente, il lettore seleziona tre valori, "Georgia", "Ohio" e "Texas", dal controllo dell'elenco a discesa del parametro. In questo caso, l'espressione seguente è equivalente al primo esempio, in cui questi tre nomi di stati vengono passati come elenco letterale da confrontare con il campo `original_state_name`. 

```
in (origin_state_name, ${stateName MultivalueParameter})
```

## Esempio con `ifelse`
<a name="in-function-example-with-ifelse"></a>

`in` può essere nidificato in altre funzioni come valore booleano. Un esempio è che gli autori possono valutare qualsiasi espressione in un elenco e restituire il valore desiderato utilizzando `in` e `ifelse`. L'esempio seguente valuta se l'oggetto `dest_state_name` di un volo si trova in un particolare elenco di stati degli Stati Uniti e restituisce diverse categorie di stati in base al confronto.

```
ifelse(in(dest_state_name,["Washington", "Oregon","California"]), "WestCoastUSState", "Other US State")
```

![\[Un'immagine dei risultati dell'esempio della funzione, sotto forma di tabella.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/in-function-with-ifelse.png)


# intToDecimal
<a name="intToDecimal-function"></a>

`intToDecimal` converte un valore intero in un tipo di dati decimale.

## Sintassi
<a name="intToDecimal-function-syntax"></a>

```
intToDecimal(integer)
```

## Arguments (Argomenti)
<a name="intToDecimal-function-arguments"></a>

 *int*   
Campo che utilizza il tipo di dati intero, un valore letterale come **14** o una chiamata a un'altra funzione che genera un intero.

## Tipo restituito
<a name="intToDecimal-function-return-type"></a>

Decimale (fisso) nell'esperienza di preparazione dei dati precedente.

Decimal (Float) nella nuova esperienza di preparazione dei dati.

## Esempio
<a name="intToDecimal-function-example"></a>

L'esempio seguente converte un campo di valori interi in un decimale.

```
intToDecimal(price)
```

I seguenti sono i valori di campo forniti.

```
20
892
57
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
20.0
892.0
58.0
```

È possibile applicare la formattazione all'interno di un'analisi, ad esempio per formattare `price` come valuta. 

# isNotNull
<a name="isNotNull-function"></a>

`isNotNull` valuta un'espressione per capire se non è null. Se l'espressione non è null, `isNotNull` restituisce true, altrimenti restituisce false.

## Sintassi
<a name="isNotNull-function-syntax"></a>

```
isNotNull(expression)
```

## Arguments (Argomenti)
<a name="isNotNull-function-arguments"></a>

 *espressione*   
L'espressione da valutare come null o meno. Può trattarsi di un nome di campo come **address1** o di una chiamata a un'altra funzione che genera una stringa. 

## Tipo restituito
<a name="isNotNull-function-return-type"></a>

Booleano

## Esempio
<a name="isNotNull-function-example"></a>

L'esempio seguente valuta il campo sales\$1amount per i valori null.

```
isNotNull(salesAmount)
```

I seguenti sono i valori di campo forniti.

```
20.13
(null)
57.54
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
true
false
true
```

# isNull
<a name="isNull-function"></a>

`isNull` valuta un'espressione per capire se è null. Se l'espressione è null, `isNull` restituisce true, altrimenti restituisce false.

## Sintassi
<a name="isNull-function-syntax"></a>

```
isNull(expression)
```

## Arguments (Argomenti)
<a name="isNull-function-arguments"></a>

 *espressione*   
L'espressione da valutare come null o meno. Può trattarsi di un nome di campo come **address1** o di una chiamata a un'altra funzione che genera una stringa. 

## Tipo restituito
<a name="isNull-function-return-type"></a>

Booleano

## Esempio
<a name="isNull-function-example"></a>

L'esempio seguente valuta il campo sales\$1amount per i valori null.

```
isNull(salesAmount)
```

I seguenti sono i valori di campo forniti.

```
20.13
(null)
57.54
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
false
true
false
```

L'esempio seguente verifica la presenza di un valore NULL in un'istruzione `ifelse` e restituisce invece un valore leggibile dall'uomo.

```
ifelse( isNull({ActiveFlag}) , 'Inactive',  'Active') 
```

# isWorkDay
<a name="isWorkDay-function"></a>

`isWorkDay` valuta un determinato valore di data e ora per determinare se si tratta di un giorno lavorativo o meno.

`isWorkDay` presuppone una settimana lavorativa standard di 5 giorni che inizia di lunedì e termina il venerdì. Si presume che il sabato e la domenica siano fine settimana. La funzione calcola sempre il risultato in base alla granularità `DAY` ed esclude la data di input specificata.

## Sintassi
<a name="isWorkDay-function-syntax"></a>

```
isWorkDay(inputDate)
```

## Arguments (Argomenti)
<a name="isWorkDay-function-arguments"></a>

 *inputDate*   
Il valore di data e ora che desideri valutare. I valori validi sono:  
+ Campo del set di dati: qualsiasi campo `date` dal set di dati a cui si sta aggiungendo questa funzione.
+ Funzione Data: qualsiasi data emessa da un'altra funzione `date`, ad esempio `parseDate`.
+ Campi calcolati: qualsiasi campo calcolato rapidamente che restituisce un `date` valore.
+ Parametri: qualsiasi `DateTime` parametro Quick.

## Tipo restituito
<a name="isWorkDay-function-return-type"></a>

Numero intero (`0` o `1`)

## Esempio
<a name="isWorkDay-function-example"></a>

L'esempio seguente determina se il campo `application_date` è un giorno lavorativo o meno.

Supponiamo che esista un campo denominato `application_date` con i seguenti valori:

```
2022-08-10 
2022-08-06 
2022-08-07
```

Quando si utilizzano questi campi e si aggiungono i seguenti calcoli, `isWorkDay` restituisce i seguenti valori:

```
isWorkDay({application_date})     
                                                     
1
0
0
```

L'esempio seguente filtra i dipendenti il cui rapporto di lavoro termina in un giorno lavorativo e determina se il loro impiego è iniziato il giorno lavorativo o il fine settimana utilizzando la formattazione condizionale:

```
is_start_date_work_day = isWorkDay(employment_start_date)
is_end_date_work_day = isWorkDay(employment_end_date)
```

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/isWorkDay-example.png)


# Left
<a name="left-function"></a>

`left` restituisce i caratteri più a sinistra di una stringa, inclusi gli spazi. Occorre specificare il numero di caratteri da restituire. 

## Sintassi
<a name="left-function-syntax"></a>

```
left(expression, limit)
```

## Arguments (Argomenti)
<a name="left-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

 *limite*   
Il numero di caratteri da recuperare da *espressione*, a partire dal primo carattere della stringa.

## Tipo restituito
<a name="left-function-return-type"></a>

Stringa

## Esempio
<a name="left-function-example"></a>

L'esempio seguente restituisce i primi 3 caratteri da una stringa.

```
left('Seattle Store #14', 3)
```

Viene restituito il valore seguente.

```
Sea
```

# Locate
<a name="locate-function"></a>

`locate` individua una sottostringa specificata all'interno di un'altra stringa e restituisce il numero di caratteri fino al primo carattere nella sottostringa. La funzione restituisce 0 se non trova la sottostringa. La funzione è basata su 1.

## Sintassi
<a name="locate-function-syntax"></a>

```
locate(expression, substring, start)
```

## Arguments (Argomenti)
<a name="locate-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

 *sottostringa*   
Il set di caratteri in *espressione* che si desidera individuare. La sottostringa può presentarsi una o più volte in *espressione*.

 *start*   
(Facoltativo) Se l'argomento *sottostringa* è presente più di una volta, utilizzare *inizio* per individuare il punto nella stringa in cui la funzione deve iniziare a cercare la sottostringa. Ad esempio, supponiamo di voler individuare il secondo esempio di una sottostringa e si pensa che in genere si presenta dopo i primi 10 caratteri. Specificare un valore di *inizio* pari a 10. Dovrebbe iniziare da 1.

## Tipo restituito
<a name="locate-function-return-type"></a>

Numero intero

## Esempi
<a name="locate-function-example"></a>

L'esempio seguente restituisce informazioni sul punto in cui appare la prima occorrenza della sottostringa "and" in una stringa.

```
locate('1 and 2 and 3 and 4', 'and')
```

Viene restituito il valore seguente.

```
3
```

L'esempio seguente restituisce informazioni sul punto in cui appare la prima occorrenza della sottostringa "and" in una stringa dopo il quarto carattere.

```
locate('1 and 2 and 3 and 4', 'and', 4)
```

Viene restituito il valore seguente.

```
9
```

# Log
<a name="log-function"></a>

`log`: restituisce il logaritmo in base 10 di una determinata espressione.

## Sintassi
<a name="log-function-syntax"></a>

```
log(expression)
```

## Arguments (Argomenti)
<a name="log-function-arguments"></a>

 *espressione*   
L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. 

# Ln
<a name="ln-function"></a>

`ln` restituisce il logaritmo naturale di una determinata espressione. 

## Sintassi
<a name="ln-function-syntax"></a>

```
ln(expression)
```

## Arguments (Argomenti)
<a name="ln-function-arguments"></a>

 *espressione*   
L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. 

# Ltrim
<a name="ltrim-function"></a>

`ltrim` rimuove lo spazio vuoto precedente da una stringa.

## Sintassi
<a name="ltrim-function-syntax"></a>

```
ltrim(expression)
```

## Arguments (Argomenti)
<a name="ltrim-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

## Tipo restituito
<a name="ltrim-function-return-type"></a>

Stringa

## Esempio
<a name="ltrim-function-example"></a>

L'esempio seguente rimuove gli spazi precedenti da una stringa.

```
ltrim('   Seattle Store #14')
```

Viene restituito il valore seguente.

```
Seattle Store #14
```

# Mod
<a name="mod-function"></a>

Utilizzare la funzione `mod` per trovare il resto dopo aver diviso il numero per il divisore. È possibile utilizzare la funzione `mod` o l'operatore modulo (%) in modo intercambiabile.

## Sintassi
<a name="mod-function-syntax"></a>

```
mod(number, divisor)
```

```
number%divisor
```

## Arguments (Argomenti)
<a name="mod-function-arguments"></a>

 *numero*   
Il numero è il numero intero positivo che si desidera dividere e di cui trovare il resto. 

 *divisore*   
Il divisore è il numero intero positivo per cui si sta dividendo. Se il divisore è zero, questa funzione restituisce un errore sulla divisione per 0.

## Esempio
<a name="mod-function-example"></a>

Gli esempi seguenti restituiscono il modulo di 17 quando si divide per 6. Il primo esempio utilizza l'operatore % e il secondo esempio utilizza la funzione MOD.

```
17%6
```

```
mod( 17, 6 )
```

Viene restituito il valore seguente.

```
5
```

# netWorkDays
<a name="netWorkDays-function"></a>

`netWorkDays`restituisce il numero di giorni lavorativi tra i due campi data forniti o anche i valori di data personalizzati generati utilizzando altre funzioni di data rapida come `parseDate` o `epochDate` come numero intero. 

`netWorkDays` presuppone una settimana lavorativa standard di 5 giorni che inizia di lunedì e termina il venerdì. Si presume che il sabato e la domenica siano fine settimana. Il calcolo include sia `startDate` che `endDate`. La funzione funziona e mostra i risultati per la granularità giornaliera. 

## Sintassi
<a name="netWorkDays-function-syntax"></a>

```
netWorkDays(startDate, endDate)
```

## Arguments (Argomenti)
<a name="netWorkDays-function-arguments"></a>

 *startDate*   
Una data valida non NULL che funge da data di inizio del calcolo.   
+ Campo del set di dati: qualsiasi campo `date` dal set di dati a cui si sta aggiungendo questa funzione.
+ Funzione Data: qualsiasi data emessa da un'altra funzione `date`, ad esempio `parseDate`.
+ Campi calcolati: qualsiasi campo calcolato in modo rapido che restituisce un `date` valore.
+ Parametri: qualsiasi `DateTime` parametro Quick.
+ Qualsiasi combinazione dei valori degli argomenti sopra indicati.

 *endDate*   
Una data valida non NULL che funge da data di fine del calcolo.   
+ Campo del set di dati: qualsiasi campo `date` dal set di dati a cui si sta aggiungendo questa funzione.
+ Funzione Data: qualsiasi data emessa da un'altra funzione `date`, ad esempio `parseDate`.
+ Campi calcolati: qualsiasi campo calcolato in modo rapido che restituisce un `date` valore.
+ Parametri: qualsiasi `DateTime` parametro Quick.
+ Qualsiasi combinazione dei valori degli argomenti sopra indicati.

## Tipo restituito
<a name="netWorkDays-function-return-type"></a>

Numero intero 

## Valori di output
<a name="netWorkDays-function-output-type"></a>

I valori di output previsti includono:
+ Numero intero positivo (quando start\$1date < end\$1date)
+ Numero intero negativo (quando start\$1date > end\$1date)
+ NULL quando uno o entrambi gli argomenti ottengono un valore nullo dal `dataset field`.

## Esempio
<a name="netWorkDays-function-example"></a>

L'esempio seguente restituisce il numero di giorni lavorativi compresi tra due date.

Supponiamo che esista un campo denominato `application_date` con i seguenti valori:

```
netWorkDays({startDate}, {endDate})
```

I seguenti sono i valori di campo forniti.

```
startDate	endDate	netWorkDays
        9/4/2022	9/11/2022	5
        9/9/2022	9/2/2022	-6
        9/10/2022	9/11/2022	0
        9/12/2022	9/12/2022	1
```

L'esempio seguente calcola il numero di giorni lavorati da ciascun dipendente e lo stipendio giornaliero speso per ogni dipendente:

```
days_worked = netWorkDays({employment_start_date}, {employment_end_date})
        salary_per_day = {salary}/{days_worked}
```

L'esempio seguente filtra i dipendenti il cui rapporto di lavoro termina in un giorno lavorativo e determina se il loro impiego è iniziato il giorno lavorativo o il fine settimana utilizzando la formattazione condizionale:

```
is_start_date_work_day = netWorkDays(employment_start_date)
        is_end_date_work_day = netWorkDays(employment_end_date)
```

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/netWorkDays-function-example.png)


# Now
<a name="now-function"></a>

Per i set di dati di database che eseguono query dirette al database, `now` restituisce la data e l'ora correnti utilizzando le impostazioni e il formato specificati dal server di database. Per i set di dati di SPICE e Salesforce, `now` restituisce la data e l'ora UTC, nel formato `yyyy-MM-ddTkk:mm:ss:SSSZ` (ad esempio, 2015-10-15T19:11:51:003Z). 

## Sintassi
<a name="now-function-syntax"></a>

```
now()
```

## Tipo restituito
<a name="now-function-return-type"></a>

Data

# notIn
<a name="notIn-function"></a>

`notIn` valuta se un'espressione esiste all'interno di un elenco di letterali. Se l'elenco non contiene l'espressione, `notIn` restituisce true, altrimenti restituisce false. `notIn` fa distinzione tra maiuscole e minuscole per gli input di tipo stringa.

`notIn` accetta due tipi di elenco di letterali, uno è un elenco inserito manualmente e l'altro è un [parametro multi-valore](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html).

## Sintassi
<a name="notIn-function-syntax"></a>

Utilizzando un elenco inserito manualmente:

```
notIn(expression, [literal-1, ...])  
```

Utilizzando un parametro multi-valore:

```
notIn(expression, $multivalue_parameter)
```

## Arguments (Argomenti)
<a name="notIn-function-arguments"></a>

 *espressione*   
L'espressione da confrontare con gli elementi dell'elenco di letterali. Può essere un nome di campo come `address`, un valore letterale come '**Unknown**', un parametro a valore singolo o una chiamata a un'altra funzione scalare, purché questa funzione non sia una funzione aggregata o un calcolo di tabella.

 *elenco di letterali*   
(obbligatorio) Può trattarsi di un elenco inserito manualmente o di un parametro multi-valore. Questo argomento accetta fino a 5.000 elementi. Tuttavia, in una query diretta a un'origine dati di terze parti, ad esempio Oracle o Teradata, la restrizione può essere minore.  
+ ***elenco inserito manualmente***: uno o più valori letterali in un elenco da confrontare con l'espressione. L'elenco deve essere racchiuso tra parentesi quadrate. Tutti i valori letterali da confrontare devono avere lo stesso tipo di dati dell'espressione. 
+ ***parametro multi-valore***: un parametro multivalore predefinito passato come elenco di letterali. Il parametro multi-valore deve avere lo stesso tipo di dati dell'espressione. 


## Tipo restituito
<a name="notIn-function-return-type"></a>

Valore booleano: TRUE/FALSE

## Esempio con un elenco inserito manualmente
<a name="notIn-function-example-manual-list"></a>

L'esempio seguente valuta il campo `origin_state_name` per i valori in un elenco di stringhe. Quando si confrontano input di tipo di stringa, `notIn` supporta solo il confronto con distinzione tra maiuscole e minuscole

```
notIn(origin_state_name,["Georgia", "Ohio", "Texas"])
```

I seguenti sono i valori di campo forniti.

```
"Washington"
        "ohio"
        "Texas"
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
true
        true
        false
```

Il terzo valore restituito è false in quanto solo "Texas" è uno dei valori esclusi.

L'esempio seguente valuta il campo `fl_date` per i valori in un elenco di stringhe. Per far corrispondere il tipo, `toString` viene utilizzato per convertire il tipo di data in un tipo di stringa.

```
notIn(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"])
```

![\[Un'immagine dei risultati dell'esempio della funzione, sotto forma di tabella.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/notin-function-example-manual-list.png)


I valori letterali e NULL sono supportati nell'argomento dell'espressione da confrontare con i valori letterali nell'elenco. Entrambi i due esempi seguenti genereranno una nuova colonna di valori FALSE. 

```
notIn("Washington",["Washington","Ohio"])
```

```
notIn(NULL,[NULL,"Ohio"])
```

## Esempio con parametro multi-valore
<a name="notIn-function-example-mutivalue-parameter"></a>

Supponiamo che un autore crei un [parametro multi-valore](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) che contiene un elenco di tutti i nomi degli stati. Quindi l'autore aggiunge un controllo per consentire al lettore di selezionare i valori dall'elenco.

Successivamente, il lettore seleziona tre valori, "Georgia", "Ohio" e "Texas", dal controllo dell'elenco a discesa del parametro. In questo caso, l'espressione seguente è equivalente al primo esempio, in cui questi tre nomi di stati vengono passati come elenco letterale da confrontare con il campo `original_state_name`. 

```
notIn (origin_state_name, ${stateName MultivalueParameter})
```

## Esempio con `ifelse`
<a name="notIn-function-example-with-ifelse"></a>

`notIn` può essere nidificato in altre funzioni come valore booleano. Un esempio è che gli autori possono valutare qualsiasi espressione in un elenco e restituire il valore desiderato utilizzando `notIn` e `ifelse`. L'esempio seguente valuta se l'oggetto `dest_state_name` di un volo si trova in un particolare elenco di stati degli Stati Uniti e restituisce diverse categorie di stati in base al confronto.

```
ifelse(notIn(dest_state_name,["Washington", "Oregon","California"]), "notWestCoastUSState", "WestCoastUSState")
```

![\[Un'immagine dei risultati dell'esempio della funzione, sotto forma di tabella.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/notin-function-with-ifelse.png)


# nullIf
<a name="nullIf-function"></a>

`nullIf` confronta due espressioni. Se sono uguali, la funzione restituisce null. Se non sono uguali, la funzione restituisce la prima espressione.

## Sintassi
<a name="nullIf-function-syntax"></a>

```
nullIf(expression1, expression2)
```

## Arguments (Argomenti)
<a name="nullIf-function-arguments"></a>

`nullIf` richiede due espressioni come argomenti. 

 *espressione*   
L'espressione può essere numerica, datetime o stringa. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. 

## Tipo restituito
<a name="nullIf-function-return-type"></a>

Stringa

## Esempio
<a name="nullIf-function-example"></a>

L'esempio seguente restituisce i valori null se il motivo di un ritardo di spedizione è sconosciuto.

```
nullIf(delayReason, 'unknown')
```

I seguenti sono i valori di campo forniti.

```
delayReason
============
unknown         
back ordered 
weather delay
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
(null)
back ordered 
weather delay
```

# parseDate
<a name="parseDate-function"></a>

`parseDate`analizza una stringa per determinare se contiene un valore di data e restituisce una data standard nel formato `yyyy-MM-ddTkk:mm:ss.SSSZ` (utilizzando la sintassi del modello di formato specificata in [Class DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) nella documentazione del progetto Joda), ad esempio 2015-10-15T 19:11:51.003 Z. Questa funzione restituisce tutte le righe che contengono una data in un formato valido e ignora ogni riga che non soddisfa tale requisito, incluse quelle che contengono valori null.

Quick supporta date nell'intervallo dal 1° gennaio 1900 00:00:00 UTC al 31 dicembre 2037 alle 23:59:59 UTC. [Per ulteriori informazioni, consulta Formati di data supportati.](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html)

## Sintassi
<a name="parseDate-function-syntax"></a>

```
parseDate(expression, ['format'])
```

## Arguments (Argomenti)
<a name="parseDate-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'1/1/2016'**, o una chiamata a un'altra funzione che genera una stringa.

 *format*   
(Facoltativo) Stringa contenente il modello del formato a cui deve corrispondere *date\$1string*. Ad esempio, se utilizzi un campo con dati simili a**01/03/2016**, specifichi il formato 'MM/dd/yyyy'. Se non viene specificato un formato, per impostazione predefinita viene impostato `yyyy-MM-dd`. Le righe i cui dati non sono conformi a *formato* vengono ignorate.   
Sono supportati diversi formati di data in base al tipo di set di dati utilizzato. Utilizzare la tabella seguente per i dettagli dei formati di data supportati.    
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/parseDate-function.html)

## Tipo restituito
<a name="parseDate-function-return-type"></a>

Data

## Esempio
<a name="parseDate-function-example"></a>

L'esempio seguente valuta `prodDate` per determinare se contiene valori di data.

```
parseDate(prodDate, 'MM/dd/yyyy')
```

I seguenti sono i valori di campo forniti.

```
prodDate
--------
01-01-1999
12/31/2006
1/18/1982 
7/4/2010
```

Per questi valori di campo vengono restituite le seguenti righe.

```
12-31-2006T00:00:00.000Z
01-18-1982T00:00:00.000Z
07-04-2010T00:00:00.000Z
```

# parseDecimal
<a name="parseDecimal-function"></a>

`parseDecimal` analizza una stringa per determinare se contiene un valore decimale. Questa funzione restituisce tutte le righe che contengono un valore decimale, intero o null e ignora le righe che non lo contengono. Se la riga contiene un valore intero, viene restituito come decimale con un massimo di 4 posizioni decimali. Ad esempio, un valore "2" viene restituito come "2,0".

## Sintassi
<a name="parseDecimal-function-syntax"></a>

```
parseDecimal(expression)
```

## Arguments (Argomenti)
<a name="parseDecimal-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'9.62'**, o una chiamata a un'altra funzione che genera una stringa.

## Tipo restituito
<a name="parseDecimal-function-return-type"></a>

Decimale (fisso) nell'esperienza di preparazione dei dati precedente.

Decimal (Float) nella nuova esperienza di preparazione dei dati.

## Esempio
<a name="parseDecimal-function-example"></a>

L'esempio seguente valuta `fee` per determinare se contiene valori decimali.

```
parseDecimal(fee)
```

I seguenti sono i valori di campo forniti.

```
fee
--------
2
2a
12.13
3b
3.9
(null)
198.353398
```

Per questi valori di campo vengono restituite le seguenti righe.

```
2.0
12.13
3.9
(null)
198.3533
```

# parseInt
<a name="parseInt-function"></a>

`parseInt` analizza una stringa per determinare se contiene un valore intero. Questa funzione restituisce tutte le righe che contengono un valore decimale, intero o null e ignora le righe che non lo contengono. Se la riga contiene un valore decimale, viene restituito come il più vicino intero, arrotondato per difetto. Ad esempio, un valore "2,99" viene restituito come "2".

## Sintassi
<a name="parseInt-function-syntax"></a>

```
parseInt(expression)
```

## Arguments (Argomenti)
<a name="parseInt-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'3'**, o una chiamata a un'altra funzione che genera una stringa.

## Tipo restituito
<a name="parseInt-function-return-type"></a>

Numero intero

## Esempio
<a name="parseInt-function-example"></a>

L'esempio seguente valuta `feeType` per determinare se contiene valori interi.

```
parseInt(feeType)
```

I seguenti sono i valori di campo forniti.

```
feeType
--------
2
2.1
2a
3
3b
(null)
5
```

Per questi valori di campo vengono restituite le seguenti righe.

```
2
2
3
(null)
5
```

# parseJson
<a name="parseJson-function"></a>

Utilizzare `parseJson` per estrarre i valori da un oggetto JSON. 

Se il set di dati è archiviato in QuickSPICE, è possibile utilizzarlo `parseJson` durante la preparazione di un set di dati, ma non nei campi calcolati durante l'analisi.

Per le query dirette, è possibile utilizzare `parseJson` sia durante la preparazione dei dati che durante l'analisi. La funzione `parseJson` si applica alle stringhe o ai tipi di dati JSON nativi, a seconda del dialetto, come mostrato nella seguente tabella.


| Dialetto | Tipo | 
| --- | --- | 
| PostgreSQL | JSON | 
| Amazon Redshift | Stringa | 
| Microsoft SQL Server | Stringa | 
| MySQL | JSON | 
| Teradata | JSON | 
| Oracle | Stringa | 
| Presto | Stringa | 
| Snowflake | Oggetto e array con tipo di dati semi-strutturato | 
| Hive | Stringa | 

## Sintassi
<a name="parseJson-function-syntax"></a>

```
parseJson(fieldName, path)
```

## Arguments (Argomenti)
<a name="parseJson-function-arguments"></a>

 *nome campo*   
Il campo contenente l'oggetto JSON che si desidera analizzare.

 *path*   
Il percorso dell'elemento dati che si desidera analizzare dall'oggetto JSON. Nell'argomento del percorso sono supportati solo lettere, numeri e spazi. La sintassi valida del percorso include:  
+ *\$1*: oggetto root
+ *.*: operatore secondario
+ *[ ]*: operatore Subscript per array

## Tipo restituito
<a name="parseJson-function-return-type"></a>

Stringa

## Esempio
<a name="parseJson-function-example-query"></a>

L'esempio seguente valuta l'oggetto JSON in entrata per recuperare un valore per la quantità di voci. Utilizzandolo durante la preparazione dei dati, è possibile creare una tabella che non include JSON.

```
parseJson({jsonField}, “$.items.qty”)
```

Di seguito è mostrato l'oggetto JSON.

```
{
    "customer": "John Doe",
    "items": {
        "product": "Beer",
        "qty": 6
    },
    "list1": [
        "val1",
        "val2"
    ],
    "list2": [
        {
            "list21key1": "list1value1"
        }
    ]
}
```

In questo esempio, viene restituito il seguente valore.

```
6
```

## Esempio
<a name="parseJson-function-example"></a>

L'esempio seguente valuta `JSONObject1` per estrarre la prima coppia chiave-valore (KVP), etichettata `"State"`, e assegnare il valore al campo calcolato che si sta creando.

```
parseJson(JSONObject1, “$.state”)
```

I seguenti sono i valori di campo forniti.

```
JSONObject1
-----------
{"State":"New York","Product":"Produce","Date Sold":"1/16/2018","Sales Amount":"$3423.39"}
{"State":"North Carolina","Product":"Bakery Products","Date Sold":"2/1/2018","Sales Amount":"$3226.42"}
{"State":"Utah","Product":"Water","Date Sold":"4/24/2018","Sales Amount":"$7001.52"}
```

Per questi valori di campo vengono restituite le seguenti righe.

```
New York
North Carolina
Utah
```

# Replace
<a name="replace-function"></a>

`replace` sostituisce parte di una stringa con un'altra stringa specificata. 

## Sintassi
<a name="replace-function-syntax"></a>

```
replace(expression, substring, replacement)
```

## Arguments (Argomenti)
<a name="replace-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

 *sottostringa*   
Il set di caratteri in *espressione* che si desidera sostituire. La sottostringa può presentarsi una o più volte in *espressione*.

 *sostituzione*   
La stringa che si desidera sostituire con *sottostringa*.

## Tipo restituito
<a name="replace-function-return-type"></a>

Stringa

## Esempio
<a name="replace-function-example"></a>

L'esempio seguente sostituisce la sottostringa "and" con "or".

```
replace('1 and 2 and 3', 'and', 'or')
```

Viene restituita la stringa seguente.

```
1 or 2 or 3
```

# Right
<a name="right-function"></a>

`right` restituisce i caratteri più a destra di una stringa, inclusi gli spazi. Occorre specificare il numero di caratteri da restituire.

## Sintassi
<a name="right-function-syntax"></a>

```
right(expression, limit)
```

## Arguments (Argomenti)
<a name="right-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

 *limite*   
Il numero di caratteri da recuperare da *espressione*, a partire dall'ultimo carattere della stringa.

## Tipo restituito
<a name="right-function-return-type"></a>

Stringa

## Esempio
<a name="right-function-example"></a>

L'esempio seguente restituisce gli ultimi cinque caratteri di una stringa.

```
right('Seattle Store#14', 12)
```

Viene restituito il valore seguente.

```
tle Store#14
```

# Round
<a name="round-function"></a>

`round` arrotonda un valore decimale all'intero più vicino se non è specificata la dimensione oppure posizione decimale più vicina se la dimensione è specificata.

## Sintassi
<a name="round-function-syntax"></a>

```
round(decimal, scale)
```

## Arguments (Argomenti)
<a name="round-function-arguments"></a>

 *decimale*   
Campo che utilizza il tipo di dati decimale, un valore letterale come **17.62** o una chiamata a un'altra funzione che genera un decimale.

 *scale*   
Il numero di posizioni decimali da utilizzare per i valori da restituire.

## Tipo restituito
<a name="round-function-return-type"></a>


| Operando | Inserisci il tipo di restituzione nell'esperienza di preparazione dei dati precedente | Inserisci la nuova esperienza di preparazione dei dati | 
| --- | --- | --- | 
|  INT  |  DECIMALE (FISSO)  |  DECIMALE (FISSO)  | 
|  DECIMALE (FISSO)  |  DECIMALE (FISSO)  |  DECIMALE (FISSO)  | 
|  DECIMALE (FLOAT)  |  DECIMALE (FISSO)  |  DECIMALE (FLOAT)  | 

## Esempio
<a name="round-function-example"></a>

L'esempio seguente arrotonda un campo di valori decimali alla seconda posizione decimale più vicina.

```
round(salesAmount, 2)
```

I seguenti sono i valori di campo forniti.

```
20.1307
892.0388
57.5447
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
20.13
892.04
58.54
```

# Rtrim
<a name="rtrim-function"></a>

`rtrim` rimuove lo spazio vuoto successivo da una stringa. 

## Sintassi
<a name="rtrim-function-syntax"></a>

```
rtrim(expression)
```

## Arguments (Argomenti)
<a name="rtrim-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

## Tipo restituito
<a name="rtrim-function-return-type"></a>

Stringa

## Esempio
<a name="rtrim-function-example"></a>

L'esempio seguente rimuove gli spazi successivi da una stringa.

```
rtrim('Seattle Store #14   ')
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
Seattle Store #14
```

# Split
<a name="split-function"></a>

`split` suddivide una stringa in un array di sottostringhe, in base a un delimitatore scelto, e restituisce la voce specificata dalla posizione.

È possibile aggiungere `split` solo a un campo calcolato durante la preparazione dei dati, non a un'analisi. Questa funzione non è supportata nelle query dirette a Microsoft SQL Server.

## Sintassi
<a name="split-function-syntax"></a>

```
split(expression, delimiter , position)
```

## Arguments (Argomenti)
<a name="split-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street;1402 35th Ave;1818 Elm Ct;11 Janes Lane'**, o una chiamata a un'altra funzione che genera una stringa.

 *delimiter*   
Carattere che delimita il punto in cui la stringa viene suddivisa in sottostringhe. Ad esempio, `split('one|two|three', '|', 2)` diventa come indicato sotto.  

```
one
two
three
```
Se si sceglie `position = 2`, `split` restituisce `'two'`.

 *posizione*   
(Obbligatorio) Posizione della voce da recuperare dall'array. La posizione della prima voce nell'array è 1.

## Tipo restituito
<a name="split-function-return-type"></a>

Array di stringhe

## Esempio
<a name="split-function-example"></a>

L'esempio seguente suddivide una stringa in un array, utilizzando il punto e virgola (;) come delimitatore, e restituisce il terzo elemento dell'array.

```
split('123 Test St;1402 35th Ave;1818 Elm Ct;11 Janes Lane', ';', 3)
```

Viene restituita la seguente voce.

```
1818 Elm Ct
```

Questa funzione ignora le voci contenenti i valori null o le stringhe vuote. 

# Sqrt
<a name="sqrt-function"></a>

`sqrt` restituisce la radice quadrata di una determinata espressione. 

## Sintassi
<a name="sqrt-function-syntax"></a>

```
sqrt(expression)
```

## Arguments (Argomenti)
<a name="sqrt-function-arguments"></a>

 *espressione*   
L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. 

# startsWith
<a name="startsWith-function"></a>

`startsWith` valuta se l'espressione inizia con una sottostringa specificata dall'utente. Se l'espressione inizia con la sottostringa, `startsWith` restituisce true, altrimenti restituisce false.

## Sintassi
<a name="startsWith-function-syntax"></a>

```
startsWith(expression, substring, string-comparison-mode)
```

## Arguments (Argomenti)
<a name="startsWith-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

 *sottostringa*   
Il set di caratteri da confrontare con l'*espressione*. La sottostringa può presentarsi una o più volte nell'*espressione*.

 *string-comparison-mode*   
(Facoltativo) Specifica la modalità di confronto delle stringhe da utilizzare:  
+ `CASE_SENSITIVE`: i confronti tra stringhe distinguono tra maiuscole e minuscole. 
+ `CASE_INSENSITIVE`: i confronti tra stringhe distinguono tra maiuscole e minuscole.
Per impostazione predefinita, questo valore è impostato su `CASE_SENSITIVE` quando è vuoto.

## Tipo restituito
<a name="startsWith-function-return-type"></a>

Booleano

## Esempi
<a name="startsWith-function-example"></a>

### Esempio predefinito che distingue tra maiuscole e minuscole
<a name="startsWith-function-example-default-case-sensitive"></a>

Il seguente esempio senza distinzione tra maiuscole e minuscole valuta se `state_nm` startsWith **New**.

```
startsWith(state_nm, "New")
```

I seguenti sono i valori di campo forniti.

```
New York
new york
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
true
false
```

### Esempio senza distinzione tra maiuscole e minuscole
<a name="startsWith-function-example-case-insensitive"></a>

Il seguente esempio con distinzione tra maiuscole e minuscole valuta se `state_nm` startsWith **new**.

```
startsWith(state_nm, "new", CASE_INSENSITIVE)
```

I seguenti sono i valori di campo forniti.

```
New York
new york
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
true
true
```

### Esempio con istruzioni condizionali
<a name="startsWith-function-example-conditional-statements"></a>

La funzione `startsWith` può essere utilizzata come istruzione condizione all'interno delle seguenti funzioni If: [avgIf](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [minIf](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) e [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). 

L'esempio seguente somma `Sales` solo se state\$1nm inizia con **New**.

```
sumIf(Sales,startsWith(state_nm, "New"))
```

### NON contiene esempi
<a name="startsWith-function-example-does-not-start-with"></a>

L'operatore `NOT` condizionale può essere utilizzato per valutare se l'espressione non inizia con la sottostringa specificata. 

```
NOT(startsWith(state_nm, "New"))
```

### Esempio di utilizzo dei valori numerici
<a name="startsWith-function-example-numeric-values"></a>

I valori numerici possono essere utilizzati negli argomenti di espressioni o sottostringhe applicando la funzione `toString`.

```
startsWith(state_nm, toString(5) )
```

# Strlen
<a name="strlen-function"></a>

`strlen` restituisce il numero di caratteri in una stringa, inclusi gli spazi.

## Sintassi
<a name="strlen-function-syntax"></a>

```
strlen(expression)
```

## Arguments (Argomenti)
<a name="strlen-function-arguments"></a>

 *espressione*   
Un'espressione può essere il nome di un campo che utilizza il tipo di dati stringa, come **address1**, un valore letterale come **'Unknown'** o un'altra funzione come `substring(field_name,0,5)`.

## Tipo restituito
<a name="strlen-function-return-type"></a>

Numero intero

## Esempio
<a name="strlen-function-example"></a>

L'esempio seguente restituisce la lunghezza della stringa specificata.

```
strlen('1421 Main Street')
```

Viene restituito il valore seguente.

```
16
```

# Substring
<a name="substring-function"></a>

`substring` restituisce i caratteri in una stringa, partendo dalla posizione specificata dall'argomento *inizio* e proseguendo con il numero di caratteri specificato dagli argomenti *lunghezza*. 

## Sintassi
<a name="substring-function-syntax"></a>

```
substring(expression, start, length)
```

## Arguments (Argomenti)
<a name="substring-function-arguments"></a>

 *espressione*   
Un'espressione può essere il nome di un campo che utilizza il tipo di dati stringa, come **address1**, un valore letterale come **'Unknown'** o un'altra funzione come `substring(field_name,1,5)`.

 *start*   
La posizione del carattere da cui iniziare. *inizio* è inclusivo, pertanto il carattere nella posizione iniziale è il primo carattere nel valore restituito. Il valore minimo per *start* è 1. 

 *length*   
Il numero di caratteri aggiuntivi da includere dopo l'argomento *inizio*. *lunghezza* include *inizio*, perciò l'ultimo carattere restituito è (*lunghezza* - 1) dopo il carattere iniziale.

## Tipo restituito
<a name="substring-function-return-type"></a>

Stringa

## Esempio
<a name="substring-function-example"></a>

L'esempio seguente restituisce dal tredicesimo al diciannovesimo carattere in una stringa. L'inizio della stringa è l'indice 1, quindi iniziate a contare dal primo carattere.

```
substring('Fantasy and Science Fiction',13,7)
```

Viene restituito il valore seguente.

```
Science
```

# switch
<a name="switch-function"></a>

`switch` confronta una *condition-expression* con le etichette letterali, all'interno di un insieme di abbinamenti di etichette letterali e *return-expression*. Quindi restituisce la *return-expression* corrispondente alla prima etichetta letterale uguale alla *condition-expression*. Se nessuna etichetta è uguale a *condition-expression*, `switch` restitusce la *default-expression*. Ogni *return-expression* e *default-expression* deve avere lo stesso tipo di dati.

## Sintassi
<a name="switch-function-syntax"></a>

```
switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...], 
        default-expression)
```

## Arguments (Argomenti)
<a name="switch-function-arguments"></a>

`switch` richiede uno o più abbinamenti di espressioni *if*,*then* e una espressione per l'argomento *else*. 

 *espressione di condizione*   
L'espressione da confrontare con i valori letterali dell'etichetta. Può trattarsi di un nome di campo come `address`, un valore letterale come `Unknown` o un'altra funzione come `toString(salesAmount)`. 

 *etichetta*   
Il letterale da confrontare con l'argomento di *condition-expression*, tutti i letterali devono avere lo stesso tipo di dati dell'argomento *condition-expression*. `switch` accetta un massimo di 5.000 etichette. 

 *return-expression*   
L'espressione da restituire se il valore della sua etichetta è uguale al valore di *condition-expression*. Può trattarsi di un nome di campo come `address`, un valore letterale come `Unknown` o un'altra funzione come `toString(salesAmount)`. Tutti gli argomenti *return-expression* devono avere lo stesso tipo di dati di *default-expression*.

 *default-expression*   
L'espressione da restituire se nessun valore di qualsiasi argomento dell'etichetta è uguale al valore di *condition-expression*. Può trattarsi di un nome di campo come `address`, un valore letterale come `Unknown` o un'altra funzione come `toString(salesAmount)`. Tutti gli argomenti *default-expression* devono avere lo stesso tipo di dati di *return-expression*.

## Tipo restituito
<a name="switch-function-return-type"></a>

`switch` restituisce un valore dello stesso tipo di dati dei valori in *return-expression*. Tutti i dati restituiti da *return-expression* e *default-expression* devono essere dello stesso tipo o essere convertiti nello stesso tipo. 

## Esempi generali
<a name="switch-function-example"></a>

L'esempio seguente restituisce il Regione AWS codice del nome della regione di input. 

```
switch(region_name, 
               "US East (N. Virginia)", "us-east-1", 
               "Europe (Ireland)", "eu-west-1", 
               "US West (N. California)", "us-west-1", 
               "other regions")
```

I seguenti sono i valori di campo forniti.

```
"US East (N. Virginia)"
        "US West (N. California)"
        "Asia Pacific (Tokyo)"
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
"us-east-1"
        "us-west-1"
        "other regions"
```

## Uso di switch per sostituire `ifelse`
<a name="switch-instead-of-ifelse"></a>

Il seguente caso d'uso `ifelse` è equivalente all'esempio precedente, per `ifelse` che valutare se i valori di un campo sono uguali a valori letterali diversi; l'uso di `switch`invece è una scelta migliore.

```
ifelse(region_name = "US East (N. Virginia)", "us-east-1", 
               region_name = "Europe (Ireland)", "eu-west-1", 
               region_name = "US West (N. California)", "us-west-1", 
               "other regions")
```

## Espressione come valore restituito
<a name="switch-expression-as-return-value"></a>

L'esempio seguente utilizza le espressioni in *return-expressions*:

```
switch({origin_city_name}, 
               "Albany, NY", {arr_delay} + 20, 
               "Alexandria, LA", {arr_delay} - 10,
               "New York, NY", {arr_delay} * 2, 
               {arr_delay})
```

L'esempio precedente modifica il tempo di ritardo previsto per ogni volo da una città particolare.

![\[Un'immagine dei risultati dell'esempio della funzione, sotto forma di tabella.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/switch-function-example.png)


# toLower
<a name="toLower-function"></a>

`toLower` formatta una stringa in tutte lettere minuscole. `toLower` ignora le righe che contengono valori null.

## Sintassi
<a name="toLower-function-syntax"></a>

```
toLower(expression)
```

## Arguments (Argomenti)
<a name="toLower-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

## Tipo restituito
<a name="toLower-function-return-type"></a>

Stringa

## Esempio
<a name="toLower-function-example"></a>

L'esempio seguente converte il valore di una stringa in lettere minuscole.

```
toLower('Seattle Store #14')
```

Viene restituito il valore seguente.

```
seattle store #14
```

# toString
<a name="toString-function"></a>

`toString` formatta l'espressione immessa come stringa. `toString` ignora le righe che contengono valori null.

## Sintassi
<a name="toString-function-syntax"></a>

```
toString(expression)
```

## Arguments (Argomenti)
<a name="toString-function-arguments"></a>

 *espressione*   
 Un'espressione può essere un campo di qualsiasi tipo di dati, un valore letterale come **14.62** o una chiamata a un'altra funzione che restituisce qualsiasi tipo di dati.

## Tipo restituito
<a name="toString-function-return-type"></a>

Stringa

## Esempio
<a name="toString-function-example"></a>

L'esempio seguente restituisce i valori di `payDate` (che usa il tipo di dati `date`) come stringhe.

```
toString(payDate)
```

I seguenti sono i valori di campo forniti.

```
payDate
--------
1992-11-14T00:00:00.000Z
2012-10-12T00:00:00.000Z
1973-04-08T00:00:00.000Z
```

Per questi valori di campo vengono restituite le seguenti righe.

```
1992-11-14T00:00:00.000Z
2012-10-12T00:00:00.000Z
1973-04-08T00:00:00.000Z
```

# toUpper
<a name="toUpper-function"></a>

`toUpper` formatta una stringa in tutte lettere maiuscole. `toUpper` ignora le righe che contengono valori null.

## Sintassi
<a name="toUpper-function-syntax"></a>

```
toUpper(expression)
```

## Arguments (Argomenti)
<a name="toUpper-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

## Tipo restituito
<a name="toUpper-function-return-type"></a>

Stringa

## Esempio
<a name="toUpper-function-example"></a>

L'esempio seguente converte il valore di una stringa in lettere maiuscole.

```
toUpper('Seattle Store #14')
```

Viene restituito il valore seguente.

```
SEATTLE STORE #14
```

# trim
<a name="trim-function"></a>

`trim` rimuove sia lo spazio vuoto precedente che quello successivo da una stringa. 

## Sintassi
<a name="trim-function-syntax"></a>

```
trim(expression)
```

## Arguments (Argomenti)
<a name="trim-function-arguments"></a>

 *espressione*   
L'espressione deve essere una stringa. Può trattarsi del nome di un campo che utilizza il tipo di dati stringa, un valore letterale come **'12 Main Street'**, o una chiamata a un'altra funzione che genera una stringa.

## Tipo restituito
<a name="trim-function-return-type"></a>

Stringa

## Esempio
<a name="trim-function-example"></a>

L'esempio seguente rimuove gli spazi successivi da una stringa.

```
trim('   Seattle Store #14   ')
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
Seattle Store #14
```

# truncDate
<a name="truncDate-function"></a>

`truncDate` restituisce un valore di data che rappresenta una parte specificata di una data Ad esempio, richiedendo la porzione dell'anno del valore 2012-09-02T00:00:00.000Z viene restituito 2012-01-01T00:00:00.000Z. Specificando un periodo relativo all'ora per una data che non contiene informazioni temporali viene restituito il valore della data iniziale, invariato.

## Sintassi
<a name="truncDate-function-syntax"></a>

```
truncDate('period', date)
```

## Arguments (Argomenti)
<a name="truncDate-function-arguments"></a>

 *punto*   
Il periodo della data che si desidera venga restituito. I periodi validi sono:  
+ YYYY: restituisce la porzione dell'anno della data.
+ Q: restituisce la data del primo giorno del trimestre al quale appartiene la data. 
+ MM: restituisce la porzione del mese della data.
+ DD: restituisce la porzione del giorno della data.
+ WK: restituisce la porzione della settimana della data. La settimana inizia di domenica in Amazon Quick.
+ HH: restituisce la porzione dell'ora della data.
+ MI: restituisce la porzione dei minuti della data.
+ SS: restituisce la porzione dei secondi della data
+ MS: restituisce la porzione dei millisecondi della data.

 *data*   
Un campo data o una chiamata a un'altra funzione che genera una data.

## Tipo restituito
<a name="truncDate-function-return-type"></a>

Data

## Esempio
<a name="truncDate-function-example"></a>

L'esempio seguente restituisce una data che indica il mese della data dell'ordine.

```
truncDate('MM', orderDate)
```

I seguenti sono i valori di campo forniti.

```
orderDate      
=========
2012-12-14T00:00:00.000Z  
2013-12-29T00:00:00.000Z
2012-11-15T00:00:00.000Z
```

Per questi valori di campo vengono restituiti i seguenti valori.

```
2012-12-01T00:00:00.000Z
2013-12-01T00:00:00.000Z
2012-11-01T00:00:00.000Z
```

# Funzioni di aggregazione
<a name="calculated-field-aggregations"></a>

Le funzioni aggregate sono disponibili solo durante l'analisi e la visualizzazione. Ciascuna di queste funzioni restituisce i valori raggruppati in base alla dimensione o alle dimensioni scelte. Per ogni aggregazione, viene anche applicata un'aggregazione condizionale. Queste eseguono lo stesso tipo di aggregazione, in base a una condizione.

Quando una formula di un campo calcolato contiene un'aggregazione, essa diventa un'aggregazione personalizzata. Per garantire che i dati vengano visualizzati correttamente, Amazon Quick applica le seguenti regole:
+ Le aggregazioni personalizzate non contengono funzioni di aggregazione nidificate. Ad esempio, questa formula non funziona: `sum(avg(x)/avg(y))`. Tuttavia, la nidificazione di funzioni non aggregate all'interno o all'esterno di funzioni aggregate funziona. Ad esempio, `ceil(avg(x))` funziona. Anche `avg(ceil(x))` funziona correttamente.
+ Le aggregazioni personalizzate non possono contenere campi aggregati e campi non aggregati, in qualsiasi combinazione. Ad esempio, questa formula non funziona: `Sum(sales)+quantity`.
+ I gruppi di filtri non possono contenere sia campi aggregati che campi non aggregati.
+ Le aggregazioni personalizzate non possono essere convertite in una dimensione. Non possono inoltre essere inserite in un contenitore di campi come dimensione.
+ In una tabella pivot, le aggregazioni personalizzate non possono essere aggiunte ai calcoli a livello di tabella.
+ I grafici a dispersione con aggregazioni personalizzate richiedono almeno una dimensione in **Group/Color (Gruppo/Colore)** nei contenitori di campi.

Per ulteriori informazioni sulle funzioni e gli operatori supportati, consulta [Funzione di campo calcolata e riferimento agli operatori per Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/calculated-field-reference.html). 

Le funzioni aggregate per i campi calcolati in Quick includono quanto segue.

**Topics**
+ [avg](avg-function.md)
+ [avgIf](avgIf-function.md)
+ [count](count-function.md)
+ [countIf](countIf-function.md)
+ [distinct\$1count](distinct_count-function.md)
+ [distinct\$1countIf](distinct_countIf-function.md)
+ [max](max-function.md)
+ [maxIf](maxIf-function.md)
+ [median](median-function.md)
+ [medianIf](medianIf-function.md)
+ [min](min-function.md)
+ [minIf](minIf-function.md)
+ [percentile](percentile-function.md)
+ [percentileCont](percentileCont-function.md)
+ [percentileDisc (percentile)](percentileDisc-function.md)
+ [periodToDateAvg](periodToDateAvg-function.md)
+ [periodToDateCount](periodToDateCount-function.md)
+ [periodToDateMax](periodToDateMax-function.md)
+ [periodToDateMedian](periodToDateMedian-function.md)
+ [periodToDateMin](periodToDateMin-function.md)
+ [periodToDatePercentile](periodToDatePercentile-function.md)
+ [periodToDatePercentileCont](periodToDatePercentileCont-function.md)
+ [periodToDateStDev](periodToDateStDev-function.md)
+ [periodToDateStDevP](periodToDateStDevP-function.md)
+ [periodToDateSum](periodToDateSum-function.md)
+ [periodToDateVar](periodToDateVar-function.md)
+ [periodToDateVarP](periodToDateVarP-function.md)
+ [stdev](stdev-function.md)
+ [stdevp](stdevp-function.md)
+ [stdevIf](stdevIf-function.md)
+ [stdevpIf](stdevpIf-function.md)
+ [sum](sum-function.md)
+ [sumIf](sumIf-function.md)
+ [var](var-function.md)
+ [varIf](varIf-function.md)
+ [varp](varp-function.md)
+ [varpIf](varpIf-function.md)

# avg
<a name="avg-function"></a>

La funzione `avg` calcola le media del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte. Ad esempio, `avg(salesAmount)` restituisce la media per la misura specificata raggruppata in base alla dimensione (facoltativa) scelta.

## Sintassi
<a name="avg-function-syntax"></a>

```
avg(decimal, [group-by level])
```

## Arguments (Argomenti)
<a name="avg-function-arguments"></a>

 *decimale*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="avg-function-example"></a>

L'esempio seguente calcola la media delle vendite.

```
avg({Sales})
```

È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). Il seguente esempio calcola la vendita media a livello di Paese, ma non in altre dimensioni (Regione o Prodotto) nell'elemento visivo.

```
avg({Sales}, [{Country}])
```

![\[I numeri di vendita media sono aggregati solo a livello di Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/avg-function-example.png)


# avgIf
<a name="avgIf-function"></a>

In base a un'istruzione condizionale, la funzione `avgIf` calcola la media del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte. Ad esempio, `avgIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` restituisce la media per quella misura raggruppata in base alla dimensione scelta (facoltativo), purché la condizione risulti vera (true).

## Sintassi
<a name="avgIf-function-syntax"></a>

```
avgIf(dimension or measure, condition) 
```

## Arguments (Argomenti)
<a name="avgIf-function-arguments"></a>

 *decimale*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# count
<a name="count-function"></a>

La funzione `count` calcola il numero di valori in una dimensione o misura, raggruppati in base alla dimensione o alle dimensioni scelte. Ad esempio, `count(product type)` restituisce il numero totale di tipi di prodotto raggruppati in base alla dimensione (facoltativa) selezionata, inclusi i duplicati. La funzione `count(sales)` restituisce il numero totale delle vendite completate raggruppate per la dimensione (facoltativa) selezionata, ad esempio il rappresentante commerciale.

## Sintassi
<a name="count-function-syntax"></a>

```
count(dimension or measure, [group-by level])
```

## Arguments (Argomenti)
<a name="count-function-arguments"></a>

 *dimensione o misura*   
L'argomento deve essere una misura o una dimensione. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="count-function-example"></a>

L'esempio seguente calcola il conteggio delle vendite in base a una dimensione specificata nell'immagine. In questo esempio, viene mostrato il conteggio delle vendite per mese.

```
count({Sales})
```

![\[Il conteggio delle vendite per mese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/count-function-example.png)


È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). L'esempio seguente calcola il conteggio delle vendite a livello di Paese, ma non in base ad altre dimensioni (Regione o Prodotto) dell'elemento visivo.

```
count({Sales}, [{Country}])
```

![\[Il conteggio delle vendite è aggregato solo a livello di Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/count-function-example2.png)


# countIf
<a name="countIf-function"></a>

In base a un'istruzione condizionale, la funzione `countIf` calcola il numero di valori univoci in una dimensione o misura, raggruppati in base alla dimensione o alle dimensioni scelte.

## Sintassi
<a name="countIf-function-syntax"></a>

```
countIf(dimension or measure, condition)
```

## Arguments (Argomenti)
<a name="countIf-function-arguments"></a>

 *dimensione o misura*   
L'argomento deve essere una misura o una dimensione. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

## Tipo restituito
<a name="countIf-function-return-type"></a>

Numero intero

## Esempio
<a name="countIf-function-example"></a>

La seguente funzione restituisce un conteggio delle transazioni di vendita (`Revenue`) che soddisfano le condizioni, inclusi eventuali duplicati. 

```
countIf (
    Revenue,
    # Conditions
        CalendarDay >= ${BasePeriodStartDate} AND 
        CalendarDay <= ${BasePeriodEndDate} AND 
        SourcingType <> 'Indirect'
)
```

# distinct\$1count
<a name="distinct_count-function"></a>

La funzione `distinct_count` calcola il numero di valori univoci in una dimensione o misura, raggruppati in base alla dimensione o alle dimensioni scelte. Ad esempio, `distinct_count(product type)` restituisce il numero totale di tipi di prodotto univoci raggruppati per la dimensione (facoltativa) selezionata, senza duplicati. La funzione `distinct_count(ship date)` restituisce il numero totale delle date di spedizione dei prodotti raggruppate per la dimensione (facoltativa) selezionata, ad esempio la regione.

## Sintassi
<a name="distinct_count-function-syntax"></a>

```
distinct_count(dimension or measure, [group-by level])
```

## Arguments (Argomenti)
<a name="distinct_count-function-arguments"></a>

 *dimensione o misura*   
L'argomento deve essere una misura o una dimensione. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempio
<a name="distinct_count-function-examples"></a>

L'esempio seguente calcola il numero totale di date in cui i prodotti sono stati ordinati, raggruppate in base alla dimensione scelta (facoltativo) nell'elemento visivo, ad esempio la regione.

```
distinct_count({Order Date})
```

![\[Il numero totale di date in cui i prodotti sono stati ordinati in ciascuna regione.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/distinct_count-function-example.png)


È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). Il seguente esempio calcola la vendita media a livello di Paese, ma non in altre dimensioni (Regione) nell'elemento visivo.

```
distinct_count({Order Date}, [Country])
```

![\[Il numero totale di date in cui i prodotti sono stati ordinati in ciascun Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/distinct_count-function-example2.png)


# distinct\$1countIf
<a name="distinct_countIf-function"></a>

In base a un'istruzione condizionale, la funzione `distinct_countIf` calcola il numero di valori distinti in una dimensione o misura, raggruppati in base alla dimensione o alle dimensioni scelte. Ad esempio, `distinct_countIf(product type)` restituisce il numero totale di tipi di prodotto univoci raggruppati per la dimensione (facoltativa) selezionata, senza duplicati. La funzione `distinct_countIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` restituisce il numero totale delle date in cui sono stati spediti i prodotti, raggruppate per la dimensione scelta (facoltativo), ad esempio la Regione, purché la condizione risulti vera (true).

## Sintassi
<a name="distinct_countIf-function-syntax"></a>

```
distinct_countIf(dimension or measure, condition)
```

## Arguments (Argomenti)
<a name="distinct_countIf-function-arguments"></a>

 *dimensione o misura*   
L'argomento deve essere una misura o una dimensione. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# max
<a name="max-function"></a>

La funzione `max` restituisce il valore massimo della misura o della data specificata, raggruppato in base alla dimensione o alle dimensioni scelte. Ad esempio, `max(sales goal)` restituisce gli obiettivi di vendita massimi raggruppati in base alla dimensione (opzionale) scelta.

## Sintassi
<a name="max-function-syntax"></a>

```
max(measure, [group-by level])
```

## Arguments (Argomenti)
<a name="max-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura o una data. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.  
Le date massime funzionano solo nel contenitore di campi **Value (Valore)** delle tabelle e delle tabelle pivot. 

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="max-function-example"></a>

Nell'esempio seguente viene restituito il valore massimo di vendita per ciascuna regione. Viene confrontato con i valori di vendita totali, minimi e mediani.

```
max({Sales})
```

![\[Il valore massimo di vendita per ogni regione.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/min-max-median-function-example.png)


È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). Il seguente esempio calcola la vendita massima a livello di Paese, ma non in altre dimensioni (Regione) nell'elemento visivo.

```
max({Sales}, [Country])
```

![\[Il valore massimo delle vendite in ogni Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/max-function-example2.png)


# maxIf
<a name="maxIf-function"></a>

In base a un'istruzione condizionale, la funzione `maxIf` restituisce il valore massimo della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte. Ad esempio, `maxIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` restituisce gli obiettivi massimi di vendita raggruppati per la dimensione scelta (facoltativo), purché la condizione risulti vera (true).

## Sintassi
<a name="maxIf-function-syntax"></a>

```
maxIf(measure, condition)
```

## Arguments (Argomenti)
<a name="maxIf-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# median
<a name="median-function"></a>

L'aggregazione `median` restituisce il valore mediano della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte. Ad esempio, `median(revenue)` restituisce il fatturato mediano raggruppato per la dimensione (facoltativa) scelta. 

## Sintassi
<a name="median-function-syntax"></a>

```
median(measure, [group-by level])
```

## Arguments (Argomenti)
<a name="median-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, vedere [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="median-function-example"></a>

Nell'esempio seguente viene restituito il valore mediano delle vendite per ciascuna Regione. Viene confrontato con i valori di vendita totale, massimo e minimo.

```
median({Sales})
```

![\[Il valore mediano di vendita per ogni regione.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/min-max-median-function-example.png)


È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). Il seguente esempio calcola la vendita mediana a livello di Paese, ma non in altre dimensioni (Regione) nell'elemento visivo.

```
median({Sales}, [Country])
```

![\[Il valore mediano delle vendite in ogni Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/median-function-example2.png)


# medianIf
<a name="medianIf-function"></a>

In base a un'istruzione condizionale, l'aggregazione `medianIf` restituisce il valore mediano della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte. Ad esempio, `medianIf(Revenue,SaleDate >= ${BasePeriodStartDate} AND SaleDate <= ${BasePeriodEndDate})` restituisce il fatturato mediano raggruppato per la dimensione scelta (facoltativo), purché la condizione risulti vera (true). 

## Sintassi
<a name="medianIf-function-syntax"></a>

```
medianIf(measure, condition)
```

## Arguments (Argomenti)
<a name="medianIf-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# min
<a name="min-function"></a>

La funzione `min` restituisce il valore minimo della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte. Ad esempio, `min(return rate)` restituisce il tasso di rendimento minimo raggruppato in base alla dimensione (opzionale) scelta.

## Sintassi
<a name="min-function-syntax"></a>

```
min(measure, [group-by level])
```

## Arguments (Argomenti)
<a name="min-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura o una data. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.  
Le date minime funzionano solo nel contenitore di campi **Value (Valore)** delle tabelle e delle tabelle pivot. 

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="min-function-example"></a>

Nell'esempio seguente viene restituito il valore minimo di vendita per ciascuna regione. Viene confrontato con i valori di vendita totale, massimo e mediano.

```
min({Sales})
```

![\[Il valore minimo di vendita per ogni regione.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/min-max-median-function-example.png)


È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). Il seguente esempio calcola la vendita minima a livello di Paese, ma non in altre dimensioni (Regione) nell'elemento visivo.

```
min({Sales}, [Country])
```

![\[Il valore minimo delle vendite in ogni Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/min-function-example2.png)


# minIf
<a name="minIf-function"></a>

In base a un'istruzione condizionale, la funzione `minIf` restituisce il valore minimo della misura specificata, raggruppato in base alla dimensione o alle dimensioni scelte. Ad esempio, `minIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` restituisce il tasso di rendimento minimo raggruppato per la dimensione scelta (facoltativo), purché la condizione risulti vera (true).

## Sintassi
<a name="minIf-function-syntax"></a>

```
minIf(measure, condition)
```

## Arguments (Argomenti)
<a name="minIf-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# percentile
<a name="percentile-function"></a>

La funzione `percentile` calcola il percentile dei valori in misura, raggruppati in base alla dimensione presente nel contenitore di campi. In Quick sono disponibili due tipi di calcolo dei percentili:
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileCont-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileCont-function.html) utilizza l'interpolazione lineare per determinare il risultato.
+ [percentileDisc(percentile)](https://docs.aws.amazon.com/quicksight/latest/user/percentileDisc-function.html) utilizza i valori effettivi per determinare il risultato. 

La funzione `percentile` è un alias di `percentileDisc`.

# percentileCont
<a name="percentileCont-function"></a>

La funzione `percentileCont` calcola il percentile in base a una distribuzione continua dei numeri nella misura. Utilizza il raggruppamento e l'ordinamento applicati nei contenitori di campi. Risponde a domande come: quali valori sono rappresentativi di questo percentile? Per restituire un valore percentile esatto che potrebbe non essere presente nel set di dati, usa `percentileCont`. Per restituire il valore percentile più vicino presente nel set di dati, usa invece `percentileDisc`.

## Sintassi
<a name="percentileCont-function-syntax"></a>

```
percentileCont(expression, percentile, [group-by level])
```

## Arguments (Argomenti)
<a name="percentileCont-function-arguments"></a>

 *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*   
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. 

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, vedete [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Valori restituiti
<a name="percentileCont-function-return-type"></a>

Il risultato della funzione è un numero. 

## Note per l’utilizzo
<a name="percentileCont-usage-notes"></a>

La funzione `percentileCont` calcola un risultato in base a una distribuzione continua dei valori di una misura specificata. Il risultato viene calcolato mediante interpolazione lineare tra i valori dopo averli ordinati in base alle impostazioni dell'elemento visivo. È diverso da `percentileDisc`, che restituisce semplicemente un valore dall'insieme di valori aggregati. Il risultato di `percentileCont` potrebbe o non potrebbe esistere nei valori della misura specificata.

## Esempio di percentileCont
<a name="percentileCont-examples"></a>

Gli esempi seguenti aiutano a spiegare come funziona percentileCont.

**Example Confronto tra mediana, `percentileCont` e `percentileDisc`**  
L'esempio seguente mostra la mediana di una dimensione (categoria) utilizzando le funzioni `median`, `percentileCont` e `percentileDisc`. Il valore mediano equivale al valore percentileCont. `percentileCont` interpola un valore, che potrebbe essere presente o meno nel set di dati. Tuttavia, poiché `percentileDisc` visualizza sempre il valore esistente nel set di dati, i due risultati potrebbero non corrispondere. L'ultima colonna in questo esempio mostra la differenza tra i due valori. Il codice per ogni campo calcolato è il seguente:  
+ `50%Cont = percentileCont( example , 50 )`
+ `median = median( example )`
+ `50%Disc = percentileDisc( example , 50 )`
+ `Cont-Disc = percentileCont( example , 50 ) − percentileDisc( example , 50 )`
+ `example = left( category, 1 )` (per fare un esempio più semplice, abbiamo usato questa espressione per abbreviare i nomi delle categorie alla prima lettera.)

```
  example     median       50%Cont      50%Disc      Cont-Disc
 -------- ----------- ------------ -------------- ------------ 
 A          22.48          22.48          22.24          0.24
 B          20.96          20.96          20.95          0.01
 C          24.92          24.92          24.92          0
 D          24.935         24.935         24.92          0.015
 E          14.48          14.48          13.99          0.49
```

**Example 100° percentile come massimo**  
Nell'esempio seguente viene illustrata una varietà di valori `percentileCont` per il campo `example`. I campi calcolati `n%Cont` sono definiti come `percentileCont( {example} ,n)`. I valori interpolati in ogni colonna rappresentano i numeri che rientrano in quel gruppo di percentili. In alcuni casi, i valori effettivi dei dati corrispondono ai valori interpolati. Ad esempio, la colonna `100%Cont` mostra lo stesso valore per ogni riga perché 6783,02 è il numero più alto.  

```
 example      50%Cont     75%Cont      99%Cont    100%Cont  
 --------- ----------- ----------- ------------ ----------- 

 A             20.97       84.307      699.99      6783.02  
 B             20.99       88.84       880.98      6783.02  
 C             20.99       90.48       842.925     6783.02  
 D             21.38       85.99       808.49      6783.02
```

È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). L'esempio seguente calcola il 30° percentile in base a una distribuzione continua dei numeri a livello di Paese, ma non tra altre dimensioni (Regione) nell'elemento visivo.

```
percentileCont({Sales}, 30, [Country])
```

![\[Il percentile delle vendite in ogni Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/percentileCont-function-example-lac.png)


# percentileDisc (percentile)
<a name="percentileDisc-function"></a>

La funzione `percentileDisc` calcola il percentile in base ai numeri effettivi in `measure`. Utilizza il raggruppamento e l'ordinamento applicati nei contenitori di campi. La funzione `percentile` è un alias di `percentileDisc`.

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 `percentileDisc`. Per restituire un valore percentile esatto che potrebbe non essere presente nel set di dati, usa invece `percentileCont`. 

## Sintassi
<a name="percentileDisc-function-syntax"></a>

```
percentileDisc(expression, percentile, [group-by level])
```

## Arguments (Argomenti)
<a name="percentileDisc-function-arguments"></a>

 *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*   
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. 

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, vedete [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Valori restituiti
<a name="percentileDisc-function-return-type"></a>

Il risultato della funzione è un numero. 

## Note per l’utilizzo
<a name="percentileDisc-usage-notes"></a>

`percentileDisc` è una funzione di distribuzione inversa che presuppone un modello di distribuzione discreta. Prende un valore percentile e una specifica di ordinamento e restituisce un elemento dall'insieme specificato. 

Per un determinato valore percentile `P`, `percentileDisc` utilizza i valori ordinati nell'elemento visivo e restituisce il valore con il valore di distribuzione cumulativa più piccolo maggiore o uguale a `P`. 

## Esempio di percentileDisc
<a name="percentileDisc-examples"></a>

Gli esempi seguenti aiutano a spiegare come funziona percentileDisc.

**Example Confronto tra mediana, `percentileDisc` e `percentileCont`**  
L'esempio seguente mostra la mediana di una dimensione (categoria) utilizzando le funzioni `percentileCont`, `percentileDisc` e `median`. Il valore mediano equivale al valore percentileCont. `percentileCont` interpola un valore, che potrebbe essere presente o meno nel set di dati. Tuttavia, poiché `percentileDisc` visualizza sempre il valore più vicino esistente nel set di dati, i due risultati potrebbero non corrispondere. L'ultima colonna in questo esempio mostra la differenza tra i due valori. Il codice per ogni campo calcolato è il seguente:  
+ `50%Cont = percentileCont( example , 50 )`
+ `median = median( example )`
+ `50%Disc = percentileDisc( example , 50 )`
+ `Cont-Disc = percentileCont( example , 50 ) − percentileDisc( example , 50 )`
+ `example = left( category, 1 )` (per fare un esempio più semplice, abbiamo usato questa espressione per abbreviare i nomi delle categorie alla prima lettera.)

```
 example     median       50%Cont      50%Disc      Cont-Disc
 -------- ----------- ------------ -------------- ------------ 
 A          22.48          22.48          22.24          0.24
 B          20.96          20.96          20.95          0.01
 C          24.92          24.92          24.92          0
 D          24.935         24.935         24.92          0.015
 E          14.48          14.48          13.99          0.49
```

**Example 100° percentile come massimo**  
Nell'esempio seguente viene illustrata una varietà di valori `percentileDisc` per il campo `example`. I campi calcolati `n%Disc` sono definiti come `percentileDisc( {example} ,n)`. I valori in ciascuna colonna sono numeri effettivi provenienti dal set di dati.   

```
 example     50%Disc      75%Disc        99%Disc      100%Disc
 -------- ----------- ------------ -------------- ------------ 
 A            20.97        73.98         699.99       6783.02
 B            42.19        88.84         820.08       6783.02
 C            30.52        90.48         733.44       6783.02
 D            41.38        85.99         901.29       6783.0
```

È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). L'esempio seguente calcola il 30° percentile in base a una distribuzione continua dei numeri a livello di Paese, ma non tra altre dimensioni (Regione) nell'elemento visivo.

```
percentile({Sales}, 30, [Country])
```

![\[Il percentile delle vendite in ogni Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/percentile-function-example-lac.png)


# periodToDateAvg
<a name="periodToDateAvg-function"></a>

La funzione `periodToDateAvg` calcola la media dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento, relativo a quel periodo.

## Sintassi
<a name="periodToDateAvg-function-syntax"></a>

```
periodToDateAvg(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateAvg-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateAvg-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateAvg(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDAvgResults.png)


# periodToDateCount
<a name="periodToDateCount-function"></a>

La funzione `periodToDateCount` calcola il numero di valori in una dimensione o misura, inclusi i duplicati, per una determinata granularità temporale (ad esempio, un trimestre) fino a un punto nel tempo, rispetto a quel periodo.

## Sintassi
<a name="periodToDateCount-function-syntax"></a>

```
periodToDateCount(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateCount-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateCount-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateCount(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDCountResults.png)


# periodToDateMax
<a name="periodToDateMax-function"></a>

La funzione `periodToDateMax` restituisce il valore massimo della misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un punto nel tempo, relativo a quel punto.

## Sintassi
<a name="periodToDateMax-function-syntax"></a>

```
periodToDateMax(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateMax-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateMax-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateMax(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDMaxResults.png)


# periodToDateMedian
<a name="periodToDateMedian-function"></a>

La funzione `periodToDateMedian` restituisce il valore della mediana della misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.

## Sintassi
<a name="periodToDateMedian-function-syntax"></a>

```
periodToDateMedian(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateMedian-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateMedian-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateMedian(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDMedianResults.png)


# periodToDateMin
<a name="periodToDateMin-function"></a>

La funzione `periodToDateMin` restituisce il valore minimo della misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.

## Sintassi
<a name="periodToDateMin-function-syntax"></a>

```
periodToDateMin(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateMin-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateMin-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateMin(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDMinResults.png)


# periodToDatePercentile
<a name="periodToDatePercentile-function"></a>

La funzione `periodToDatePercentile` calcola il percentile in base ai numeri effettivi misurati per una determinata granularità temporale (ad esempio, un trimestre) fino a un punto nel tempo, rispetto a quel periodo. Utilizza il raggruppamento e l'ordinamento applicati nei contenitori di campi.

Per restituire il valore percentile più vicino presente nel set di dati, usa `periodToDatePercentile`. Per restituire un valore percentile esatto che potrebbe non essere presente nel set di dati, usa invece `periodToDatePercentileCont`.

## Sintassi
<a name="periodToDatePercentile-function-syntax"></a>

```
periodToDatePercentile(
	measure, 
	percentile, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDatePercentile-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *percentile*   
Il valore percentile può essere qualsiasi costante numerica compresa tra 0 e 100. Un percentile di 50 calcola il valore mediano della misura.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDatePercentile-function-example"></a>

L'esempio seguente calcola il week-to-date 90° percentile dell'importo della tariffa per tipo di pagamento per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDatePercentile(fare_amount, 90, pickupDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDPercentileResults.png)


# periodToDatePercentileCont
<a name="periodToDatePercentileCont-function"></a>

La funzione `periodToDatePercentileCont` calcola il percentile in base a una distribuzione continua dei numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento. Utilizza il raggruppamento e l'ordinamento applicati nei contenitori di campi.

Per restituire un valore percentile esatto che potrebbe non essere presente nel set di dati, usa `periodToDatePercentileCont`. Per restituire il valore percentile più vicino presente nel set di dati, usa invece `periodToDatePercentile`.

## Sintassi
<a name="periodToDatePercentileCont-function-syntax"></a>

```
periodToDatePercentileCont(
	measure, 
	percentile, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDatePercentileCont-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *percentile*   
Il valore percentile può essere qualsiasi costante numerica compresa tra 0 e 100. Un percentile di 50 calcola il valore mediano della misura.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDatePercentileCont-function-example"></a>

L'esempio seguente calcola il week-to-date 90° percentile dell'importo della tariffa per tipo di pagamento per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDatePercentileCont(fare_amount, 90, pickupDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDContPercentileResults.png)


# periodToDateStDev
<a name="periodToDateStDev-function"></a>

La funzione `periodToDateStDev` calcola la deviazione standard dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un punto nel tempo, sulla base di un campione e relativa a quel periodo.

## Sintassi
<a name="periodToDateStDev-function-syntax"></a>

```
periodToDateStDev(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateStDev-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateStDev-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateStDev(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDStDevResults.png)


# periodToDateStDevP
<a name="periodToDateStDevP-function"></a>

La funzione `periodToDateStDevP` calcola la deviazione standard della popolazione dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un punto nel tempo, sulla base di un campione e relativa a quel periodo.

## Sintassi
<a name="periodToDateStDevP-function-syntax"></a>

```
periodToDateStDevP(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateStDevP-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateStDevP-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateStDevP(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDStDevPResults.png)


# periodToDateSum
<a name="periodToDateSum-function"></a>

La funzione `periodToDateSum` aggiunge la misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.

## Sintassi
<a name="periodToDateSum-function-syntax"></a>

```
periodToDateSum(
	measure, 
	dateTime, 
	period, 
	endDate)
```

## Arguments (Argomenti)
<a name="periodToDateSum-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateSum-function-example"></a>

La seguente funzione calcola la somma settimanale dell'importo della tariffa per pagamento, per la settimana dal 30-06-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateSum(fare_amount, pickUpDateTime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati per l'esempio con illustrazioni.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDSumResults.png)


# periodToDateVar
<a name="periodToDateVar-function"></a>

La funzione `periodToDateVar` calcola la varianza campione dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.

## Sintassi
<a name="periodToDateVar-function-syntax"></a>

```
periodToDateVar(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateVar-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateVar-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateVar(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDVarResults.png)


# periodToDateVarP
<a name="periodToDateVarP-function"></a>

La funzione `periodToDateVarP` calcola la varianza della popolazione dell'insieme di numeri nella misura specificata per una determinata granularità temporale (ad esempio, un trimestre) fino a un punto nel tempo, rilevante per quel periodo.

## Sintassi
<a name="periodToDateVarP-function-syntax"></a>

```
periodToDateVarP(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Arguments (Argomenti)
<a name="periodToDateVarP-function-arguments"></a>

 *misura*   
L'argomento deve essere un campo. I valori null vengono omessi dai risultati. I valori letterali non funzionano.

 *dateTime*   
La dimensione Data sulla quale calcoli le PeriodToDate aggregazioni.

 *punto*   
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`.

 *endDate*   
(Facoltativo) La dimensione della data in cui stai terminando le periodToDate aggregazioni di calcolo. Se omesso, l'impostazione predefinita è `now()`.

## Esempio
<a name="periodToDateVarP-function-example"></a>

L'esempio seguente calcola l'importo week-to-date minimo della tariffa per tipo di pagamento, per la settimana dal 06-30-21. Per semplificare l'esempio, abbiamo filtrato un solo pagamento. Il 30-06-21 è mercoledì. Quick inizia la settimana la domenica. Nel nostro esempio, è il 27-06-21.

```
periodToDateVarP(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Questa è un'immagine dei risultati del calcolo di esempio.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/PTDVarPResults.png)


# stdev
<a name="stdev-function"></a>

La funzione `stdev` calcola la deviazione standard del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte, in base a un campione.

## Sintassi
<a name="stdev-function-syntax"></a>

```
stdev(measure, [group-by level])
```

## Arguments (Argomenti)
<a name="stdev-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="stdev-function-example"></a>

L'esempio seguente restituisce la deviazione standard dei punteggi dei test per una classe, utilizzando un campione dei punteggi dei test registrati.

```
stdev({Score})
```

È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). L'esempio seguente calcola la deviazione standard dei punteggi dei test a livello di oggetto, ma non tra altre dimensioni (classe) nell'elemento visivo.

```
stdev({Score}, [Subject])
```

# stdevp
<a name="stdevp-function"></a>

La funzione `stdevp` calcola la deviazione standard del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte.

## Sintassi
<a name="stdevp-function-syntax"></a>

```
stdevp(measure, [group-by level])
```

## Arguments (Argomenti)
<a name="stdevp-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="stdev-function-example"></a>

L'esempio seguente restituisce la deviazione standard dei punteggi dei test per una classe, utilizzando tutti i punteggi registrati.

```
stdevp({Score})
```

È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). L'esempio seguente calcola la deviazione standard dei punteggi dei test a livello di soggetto, ma non rispetto ad altre dimensioni (classe) dell'immagine utilizzando tutti i punteggi registrati.

```
stdevp({Score}, [Subject])
```

# stdevIf
<a name="stdevIf-function"></a>

In base a un'istruzione condizionale, la funzione `stdevIf` calcola la deviazione standard del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte, in base a un campione. 

## Sintassi
<a name="stdevIf-function-syntax"></a>

```
stdevIf(measure, conditions)
```

## Arguments (Argomenti)
<a name="stdevIf-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# stdevpIf
<a name="stdevpIf-function"></a>

In base a un'istruzione condizionale, la funzione `stdevpIf` calcola la deviazione standard del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelto, in base a una popolazione parziale.

## Sintassi
<a name="stdevpIf-function-syntax"></a>

```
stdevpIf(measure, conditions)
```

## Arguments (Argomenti)
<a name="stdevpIf-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# sum
<a name="sum-function"></a>

La funzione `sum` somma il set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte. Ad esempio, `sum(profit amount)` restituisce l'importo totale dei ricavi raggruppati in base alla dimensione (facoltativa) scelta.

## Sintassi
<a name="sum-function-syntax"></a>

```
sum(measure, [group-by level])
```

## Arguments (Argomenti)
<a name="sum-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="sum-function-example"></a>

L'esempio seguente restituisce la somma delle vendite.

```
sum({Sales})
```

È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). L'esempio seguente calcola la somma delle vendite a livello di Paese, ma non tra le altre dimensioni (Regione e Prodotto) dell'elemento visivo.

```
sum(Sales, [Country])
```

![\[La somma delle vendite per ogni Paese.\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/sum-function-example.png)


# sumIf
<a name="sumIf-function"></a>

In base a un'istruzione condizionale, la funzione `sumIf` somma il set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte. Ad esempio, `sumIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` restituisce l'importo totale del profitto raggruppato in base alla dimensione scelta (facoltativo), se la condizione è true.

## Sintassi
<a name="sumIf-function-syntax"></a>

```
sumIf(measure, conditions)
```

## Arguments (Argomenti)
<a name="sumIf-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

## Esempi
<a name="sumIf-function-example"></a>

L'esempio seguente utilizza un campo calcolato con `sumIf` per visualizzare gli importi delle vendite se `Segment` è uguale a `SMB`.

```
sumIf(Sales, Segment=’SMB’)
```

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/quick/latest/userguide/images/sumIfCalc.png)


L'esempio seguente utilizza un campo calcolato con `sumIf` per visualizzare gli importi delle vendite se `Segment` è uguale a `SMB` e `Order Date` è maggiore dell'anno 2022.

```
sumIf(Sales, Segment=’SMB’ AND {Order Date} >=’2022-01-01’)
```

# var
<a name="var-function"></a>

La funzione `var` calcola la varianza campione dei set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte.

## Sintassi
<a name="var-function-syntax"></a>

```
var(measure, [group-by level])
```

## Arguments (Argomenti)
<a name="var-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="var-function-example"></a>

Nell'esempio seguente viene restituita la varianza di un campione di punteggi dei test.

```
var({Scores})
```

È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). L'esempio seguente restituisce la varianza di un campione di punteggi dei test a livello di oggetto, ma non tra altre dimensioni (classe) nell'elemento visivo.

```
var({Scores}, [Subject]
```

# varIf
<a name="varIf-function"></a>

In base a un'istruzione condizionale, la funzione `varIf` calcola la varianza dei set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte, in base a un campione.

## Sintassi
<a name="varIf-function-syntax"></a>

```
varIf(measure, conditions)
```

## Arguments (Argomenti)
<a name="varIf-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# varp
<a name="varp-function"></a>

La funzione `varp` calcola la varianza della popolazione del set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte.

## Sintassi
<a name="varp-function-syntax"></a>

```
varp(measure, [group-by level])
```

## Arguments (Argomenti)
<a name="varp-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *raggruppa per livello*   
(Facoltativo) Specifica il livello in base al quale raggruppare l'aggregazione. Il livello aggiunto può essere qualsiasi dimensione indipendente dalle dimensioni aggiunte all'elemento visivo.  
L'argomento deve essere un campo di dimensione. L'opzione raggruppa per livello deve essere racchiuso tra parentesi quadre `[ ]`. Per ulteriori informazioni, consulta [Calcolo con riconoscimento del livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Esempi
<a name="varp-function-example"></a>

Nell'esempio seguente viene restituita la varianza di una popolazione di punteggi dei test.

```
varp({Scores})
```

È inoltre possibile specificare a quale livello raggruppare il calcolo utilizzando una o più dimensioni nella vista o nel set di dati. Questa è chiamata funzione LAC-A. Per ulteriori informazioni sulle funzioni LAC-A, vedere Calcolo con riconoscimento del [livello - funzioni aggregate (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). L'esempio seguente restituisce la varianza di una popolazione di punteggi dei test a livello di oggetto, ma non tra altre dimensioni (Class) nell'elemento visivo.

```
varp({Scores}, [Subject]
```

# varpIf
<a name="varpIf-function"></a>

In base a un'istruzione condizionale, la funzione `varpIf` calcola la varianza dei set di numeri nella misura specificata, raggruppati in base alla dimensione o alle dimensioni scelte, in base a una popolazione parziale.

## Sintassi
<a name="varpIf-function-syntax"></a>

```
varpIf(measure, conditions)
```

## Arguments (Argomenti)
<a name="varpIf-function-arguments"></a>

 *misura*   
L'argomento deve essere una misura. I valori null vengono omessi dai risultati. I valori letterali non funzionano. L'argomento deve essere un campo.

 *condizione*   
Una o più condizioni in una singola istruzione.

# Funzioni di calcolo delle tabelle
<a name="table-calculation-functions"></a>

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
<a name="difference-function"></a>

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
<a name="difference-function-syntax"></a>

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)
<a name="difference-function-arguments"></a>

 *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
<a name="difference-function-example"></a>

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
<a name="distinctCountOver-function"></a>

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
<a name="distinctCountOver-function-syntax"></a>

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)
<a name="distinctCountOver-function-arguments"></a>

 *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
<a name="distinctCountOver-function-example"></a>

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
<a name="lag-function"></a>

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
<a name="lag-function-syntax"></a>

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)
<a name="lag-function-arguments"></a>

*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
<a name="lag-function-example"></a>

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
<a name="lead-function"></a>

La funzione `lead` calcola il valore iniziale (seguente) per una misura in base ai partizionamenti e agli ordinamenti specificati.

## Sintassi
<a name="lead-function-syntax"></a>

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)
<a name="lead-function-arguments"></a>

*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
<a name="lead-function-example"></a>

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
<a name="percentDifference-function"></a>

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
<a name="percentDifference-function-syntax"></a>

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)
<a name="percentDifference-function-arguments"></a>

 *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
<a name="percentDifference-function-example"></a>

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
<a name="avgOver-function"></a>

La funzione `avgOver` calcola la media di una misura divisa per un elenco di dimensioni. 

## Sintassi
<a name="avgOver-function-syntax"></a>

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)
<a name="avgOver-function-arguments"></a>

 *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
<a name="avgOver-function-example"></a>

L'esempio seguente recupera la media cumulativa di `sum(Sales)` partizionata per `City` e `State`. 

```
avgOver
(
     sum(Sales), 
     [City, State]
)
```

# countOver
<a name="countOver-function"></a>

La funzione `countOver` calcola il conteggio di una dimensione o una misura diviso per un elenco di dimensioni. 

## Sintassi
<a name="countOver-function-syntax"></a>

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)
<a name="countOver-function-arguments"></a>

 *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
<a name="countOver-function-example"></a>

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
<a name="maxOver-function"></a>

La funzione `maxOver` calcola il valore massimo di una misura o una data diviso per un elenco di dimensioni. 

## Sintassi
<a name="maxOver-function-syntax"></a>

Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.

```
maxOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Arguments (Argomenti)
<a name="maxOver-function-arguments"></a>

 *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
<a name="maxOver-function-example"></a>

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
<a name="minOver-function"></a>

La funzione `minOver` calcola il valore minimo di una misura o una data diviso per un elenco di dimensioni. 

## Sintassi
<a name="minOver-function-syntax"></a>

Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.

```
minOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Arguments (Argomenti)
<a name="minOver-function-arguments"></a>

*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
<a name="minOver-function-example"></a>

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
<a name="percentileOver-function"></a>

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
<a name="percentileContOver-function"></a>

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
<a name="percentileContOver-function-syntax"></a>

```
percentileContOver (
    measure
  , percentile-n
  , [partition-by, …]
  , calculation-level
)
```

## Arguments (Argomenti)
<a name="percentileContOver-function-arguments"></a>

 *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
<a name="percentileContOver-function-return-type"></a>

Il risultato della funzione è un numero. 

## Esempio di percentileContOver
<a name="percentileContOver-examples"></a>

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
<a name="percentileDiscOver-function"></a>

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
<a name="percentileDiscOver-function-syntax"></a>

```
percentileDiscOver (
     measure
   , percentile-n
   , [partition-by, …]
   , calculation-level
)
```

## Arguments (Argomenti)
<a name="percentileDiscOver-function-arguments"></a>

 *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
<a name="percentileDiscOver-function-return-type"></a>

Il risultato della funzione è un numero. 

## Esempio di percentileDiscOver
<a name="percentileDiscOver-examples"></a>

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
<a name="percentOfTotal-function"></a>

La funzione `percentOfTotal` calcola la percentuale in cui una misura contribuisce al totale, in base alle dimensioni specificate. 

## Sintassi
<a name="percentOfTotal-function-syntax"></a>

Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.

```
percentOfTotal
(
     measure 
     ,[ partition_field, ... ] 
)
```

## Arguments (Argomenti)
<a name="percentOfTotal-function-arguments"></a>

 *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
<a name="percentOfTotal-function-example"></a>

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
<a name="periodOverPeriodDifference-function"></a>

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
<a name="periodOverPeriodDifference-function-syntax"></a>

```
periodOverPeriodDifference(
	measure, 
	date, 
	period, 
	offset)
```

## Arguments (Argomenti)
<a name="periodOverPeriodDifference-function-arguments"></a>

 *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
<a name="periodOverPeriodDifference-function-example"></a>

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
<a name="periodOverPeriodLastValue-function"></a>

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
<a name="periodOverPeriodLastValue-function-syntax"></a>

```
periodOverPeriodLastValue(
	measure, 
	date, 
	period, 
	offset)
```

## Arguments (Argomenti)
<a name="periodOverPeriodLastValue-function-arguments"></a>

 *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
<a name="periodOverPeriodLastValue-function-example"></a>

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
<a name="periodOverPeriodPercentDifference-function"></a>

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
<a name="periodOverPeriodPercentDifference-function-syntax"></a>

```
periodOverPeriodPercentDifference(
	measure, 
	date, 
	period, 
	offset)
```

## Arguments (Argomenti)
<a name="periodOverPeriodPercentDifference-function-arguments"></a>

 *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
<a name="periodOverPeriodPercentDifference-function-example"></a>

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
<a name="periodToDateAvgOverTime-function"></a>

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
<a name="periodToDateAvgOverTime-function-syntax"></a>

```
periodToDateAvgOverTime(
	measure, 
	dateTime,
	period)
```

## Arguments (Argomenti)
<a name="periodToDateAvgOverTime-function-arguments"></a>

 *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
<a name="periodToDateAvgOverTime-function-example"></a>

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
<a name="periodToDateCountOverTime-function"></a>

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
<a name="periodToDateCountOverTime-function-syntax"></a>

```
periodToDateCountOverTime(
	measure, 
	dateTime, 
	period)
```

## Arguments (Argomenti)
<a name="periodToDateCountOverTime-function-arguments"></a>

 *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
<a name="periodToDateCountOverTime-function-example"></a>

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
<a name="periodToDateMaxOverTime-function"></a>

La funzione `periodToDateMaxOverTime` calcola il massimo di una misura per una determinata granularità temporale (ad esempio, un trimestre) fino a un determinato momento.

## Sintassi
<a name="periodToDateMaxOverTime-function-syntax"></a>

```
periodToDateMaxOverTime(
	measure, 
	dateTime, 
	period)
```

## Arguments (Argomenti)
<a name="periodToDateMaxOverTime-function-arguments"></a>

 *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
<a name="periodToDateMaxOverTime-function-example"></a>

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
<a name="periodToDateMinOverTime-function"></a>

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
<a name="periodToDateMinOverTime-function-syntax"></a>

```
periodToDateMinOverTime(
	measure, 
	dateTime, 
	period)
```

## Arguments (Argomenti)
<a name="periodToDateMinOverTime-function-arguments"></a>

 *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
<a name="periodToDateMinOverTime-function-example"></a>

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
<a name="periodToDateSumOverTime-function"></a>

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
<a name="periodToDateSumOverTime-function-syntax"></a>

```
periodToDateSumOverTime(
	measure, 
	dateTime, 
	period)
```

## Arguments (Argomenti)
<a name="periodToDateSumOverTime-function-arguments"></a>

 *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
<a name="periodToDateSumOverTime-function-example"></a>

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
<a name="stdevOver-function"></a>

La funzione `stdevOver` calcola la deviazione standard della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a un campione. 

## Sintassi
<a name="stdevOver-function-syntax"></a>

Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.

```
stdevOver
(
      measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Arguments (Argomenti)
<a name="stdevOver-function-arguments"></a>

*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
<a name="stdevOver-function-example"></a>

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
<a name="stdevpOver-function"></a>

La funzione `stdevpOver` calcola la deviazione standard della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a una popolazione parziale.

## Sintassi
<a name="stdevpOver-function-syntax"></a>

Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.

```
stdevpOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Arguments (Argomenti)
<a name="stdevpOver-function-arguments"></a>

*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
<a name="stdevpOver-function-example"></a>

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
<a name="varOver-function"></a>

La funzione `varOver` calcola la varianza della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a un campione. 

## Sintassi
<a name="varOver-function-syntax"></a>

Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.

```
varOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Arguments (Argomenti)
<a name="varOver-function-arguments"></a>

*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
<a name="varOver-function-example"></a>

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
<a name="varpOver-function"></a>

La funzione `varpOver` calcola la varianza della misura specificata, partizionata dall'attributo o dagli attributi scelti, in base a una popolazione parziale. 

## Sintassi
<a name="varpOver-function-syntax"></a>

Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.

```
varpOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Arguments (Argomenti)
<a name="varpOver-function-arguments"></a>

*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
<a name="varpOver-function-example"></a>

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
<a name="sumOver-function"></a>

 La funzione `sumOver` calcola la somma di una misura divisa per un elenco di dimensioni. 

## Sintassi
<a name="sumOver-function-syntax"></a>

Le parentesi sono obbligatorie. Per vedere quali argomenti sono facoltativi, consulta le seguenti descrizioni.

```
sumOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Arguments (Argomenti)
<a name="sumOver-function-arguments"></a>

*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
<a name="sumOver-function-example"></a>

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
<a name="denseRank-function"></a>

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
<a name="denseRank-function-syntax"></a>

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)
<a name="denseRank-function-arguments"></a>

 *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
<a name="denseRank-function-example"></a>

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
<a name="rank-function"></a>

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
<a name="rank-function-syntax"></a>

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)
<a name="rank-function-arguments"></a>

 *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
<a name="rank-function-example"></a>

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
<a name="percentileRank-function"></a>

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
<a name="percentileRank-function-syntax"></a>

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)
<a name="percentileRank-function-arguments"></a>

 *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
<a name="percentileRank-function-example"></a>

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
<a name="runningAvg-function"></a>

La funzione `runningAvg` calcola una media in esecuzione per una misura in base alle dimensioni e agli ordinamenti specificati. 

## Sintassi
<a name="runningAvg-function-syntax"></a>

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)
<a name="runningAvg-function-arguments"></a>

 *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
<a name="runningAvg-function-example"></a>

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
<a name="runningCount-function"></a>

La funzione `runningCount` calcola un conteggio in esecuzione per una misura o una dimensione, in base alle dimensioni e agli ordinamenti specificati. 

## Sintassi
<a name="runningCount-function-syntax"></a>

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)
<a name="runningCount-function-arguments"></a>

 *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
<a name="runningCount-function-example"></a>

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
<a name="runningMax-function"></a>

La funzione `runningMax` calcola un valore massimo in esecuzione per una misura in base alle dimensioni e agli ordinamenti specificati. 

## Sintassi
<a name="runningMax-function-syntax"></a>

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)
<a name="runningMax-function-arguments"></a>

 *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
<a name="runningMax-function-example"></a>

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
<a name="runningMin-function"></a>

La funzione `runningMin` calcola un valore minimo corrente per una misura in base alle dimensioni e agli ordinamenti specificati. 

## Sintassi
<a name="runningMin-function-syntax"></a>

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)
<a name="runningMin-function-arguments"></a>

 *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
<a name="runningMin-function-example"></a>

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
<a name="runningSum-function"></a>

La funzione `runningSum` calcola una somma in esecuzione per una misura in base alle dimensioni e agli ordinamenti specificati. 

## Sintassi
<a name="runningSum-function-syntax"></a>

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)
<a name="runningSum-function-arguments"></a>

 *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
<a name="runningSum-function-example"></a>

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
<a name="firstValue-function"></a>

La funzione `firstValue` calcola il primo valore della dimensione o della misura aggregata divisa e ordinata in base agli attributi specificati.

## Sintassi
<a name="firstValue-function-syntax"></a>

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)
<a name="firstValue-function-arguments"></a>

*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
<a name="firstValue-function-example"></a>

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
<a name="lastValue-function"></a>

La funzione `lastValue` calcola l'ultimo valore della dimensione o della misura aggregata divisa e ordinata in base agli attributi specificati.

## Sintassi
<a name="lastValue-function-syntax"></a>

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)
<a name="lastValue-function-arguments"></a>

*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
<a name="lastValue-function-example"></a>

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
<a name="windowAvg-function"></a>

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
<a name="windowAvg-function-syntax"></a>

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)
<a name="windowAvg-function-arguments"></a>

*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
<a name="windowAvg-function-example"></a>

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
<a name="windowCount-function"></a>

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
<a name="windowCount-function-syntax"></a>

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)
<a name="windowCount-function-arguments"></a>

*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
<a name="windowCount-function-example"></a>

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
<a name="windowMax-function"></a>

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
<a name="windowMax-function-syntax"></a>

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)
<a name="windowMax-function-arguments"></a>

*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
<a name="windowMax-function-example"></a>

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
<a name="windowMin-function"></a>

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
<a name="windowMin-function-syntax"></a>

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)
<a name="windowMin-function-arguments"></a>

*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
<a name="windowMin-function-example"></a>

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
<a name="windowSum-function"></a>

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
<a name="windowSum-function-syntax"></a>

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)
<a name="windowSum-function-arguments"></a>

*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
<a name="windowSum-function-example"></a>

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)
