Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Funzioni 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 `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 ``` addDateTime(amount, period, datetime) ``` ## Arguments (Argomenti) *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 Datetime ## Esempio 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 `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 ``` addWorkDays(initDate, numWorkDays) ``` ## Arguments (Argomenti) *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 Numero intero ## Valori di output 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 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 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 `abs` restituisce il valore assoluto di una determinata espressione. ## Sintassi ``` abs(expression) ``` ## Arguments (Argomenti) *espressione* L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. # Ceil `ceil` arrotonda un valore decimale al successivo intero più alto Ad esempio, `ceil(29.02)` restituisce `30`. ## Sintassi ``` ceil(decimal) ``` ## Arguments (Argomenti) *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 Numero intero ## Esempio 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 `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 ``` coalesce(expression1, expression2 [, expression3, ...]) ``` ## Arguments (Argomenti) `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 `coalesce` restituisce un valore dello stesso tipo di dati degli argomenti di input. ## Esempio 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 `concat` concatena due o più stringhe. ## Sintassi ``` concat(expression1, expression2 [, expression3 ...]) ``` ## Arguments (Argomenti) `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 Stringa ## Esempi 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 `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 ``` contains(expression, substring, string-comparison-mode) ``` ## Arguments (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. *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 Booleano ## Esempi ### Esempio predefinito che distingue tra maiuscole e minuscole 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 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 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 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 I valori numerici possono essere utilizzati negli argomenti di espressioni o sottostringhe applicando la funzione `toString`. ``` contains(state_nm, toString(5) ) ``` # decimalToInt `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 ``` decimalToInt(decimal) ``` ## Arguments (Argomenti) *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 Numero intero ## Esempio 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 `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 ``` dateDiff(date1, date2,[period]) ``` ## Arguments (Argomenti) `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 Numero intero ## Esempio 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 `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 ``` endsWith(expression, substring, string-comparison-mode) ``` ## Arguments (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. *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 Booleano ## Esempi ### Esempio predefinito che distingue tra maiuscole e minuscole 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 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 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 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 I valori numerici possono essere utilizzati negli argomenti di espressioni o sottostringhe applicando la funzione `toString`. ``` endsWith(state_nm, toString(5) ) ``` # epochDate `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 ``` epochDate(epochdate) ``` ## Arguments (Argomenti) *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 Data ## Esempio 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 `exp` restituisce la base del logaritmo naturale in base e elevato alla potenza di una determinata espressione. ## Sintassi ``` exp(expression) ``` ## Arguments (Argomenti) *espressione* L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. # Extract `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 ``` extract(period, date) ``` ## Arguments (Argomenti) *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 Numero intero ## Esempio 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 `floor` riduce un valore decimale al successivo intero più basso Ad esempio, `floor(29.08)` restituisce `29`. ## Sintassi ``` floor(decimal) ``` ## Arguments (Argomenti) *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 Numero intero ## Esempio 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 `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 ``` formatDate(date, ['format']) ``` ## Arguments (Argomenti) *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 Stringa ## Esempio 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 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 `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 ``` ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression) ``` ## Arguments (Argomenti) `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 `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 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 *``*. 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', /**/ /*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 `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 Utilizzando un elenco inserito manualmente: ``` in(expression, [literal-1, ...]) ``` Utilizzando un parametro multi-valore: ``` in(expression, $multivalue_parameter) ``` ## Arguments (Argomenti) *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 Valore booleano: TRUE/FALSE ## Esempio con un elenco statico 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 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` `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 `intToDecimal` converte un valore intero in un tipo di dati decimale. ## Sintassi ``` intToDecimal(integer) ``` ## Arguments (Argomenti) *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 Decimale (fisso) nell'esperienza di preparazione dei dati precedente. Decimal (Float) nella nuova esperienza di preparazione dei dati. ## Esempio 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 `isNotNull` valuta un'espressione per capire se non è null. Se l'espressione non è null, `isNotNull` restituisce true, altrimenti restituisce false. ## Sintassi ``` isNotNull(expression) ``` ## Arguments (Argomenti) *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 Booleano ## Esempio 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 `isNull` valuta un'espressione per capire se è null. Se l'espressione è null, `isNull` restituisce true, altrimenti restituisce false. ## Sintassi ``` isNull(expression) ``` ## Arguments (Argomenti) *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 Booleano ## Esempio 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 `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 ``` isWorkDay(inputDate) ``` ## Arguments (Argomenti) *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 Numero intero (`0` o `1`) ## Esempio 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 `left` restituisce i caratteri più a sinistra di una stringa, inclusi gli spazi. Occorre specificare il numero di caratteri da restituire. ## Sintassi ``` left(expression, limit) ``` ## Arguments (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. *limite* Il numero di caratteri da recuperare da *espressione*, a partire dal primo carattere della stringa. ## Tipo restituito Stringa ## Esempio L'esempio seguente restituisce i primi 3 caratteri da una stringa. ``` left('Seattle Store #14', 3) ``` Viene restituito il valore seguente. ``` Sea ``` # Locate `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 ``` locate(expression, substring, start) ``` ## Arguments (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. *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 Numero intero ## Esempi 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 `log`: restituisce il logaritmo in base 10 di una determinata espressione. ## Sintassi ``` log(expression) ``` ## Arguments (Argomenti) *espressione* L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. # Ln `ln` restituisce il logaritmo naturale di una determinata espressione. ## Sintassi ``` ln(expression) ``` ## Arguments (Argomenti) *espressione* L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. # Ltrim `ltrim` rimuove lo spazio vuoto precedente da una stringa. ## Sintassi ``` ltrim(expression) ``` ## Arguments (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 Stringa ## Esempio L'esempio seguente rimuove gli spazi precedenti da una stringa. ``` ltrim(' Seattle Store #14') ``` Viene restituito il valore seguente. ``` Seattle Store #14 ``` # Mod 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 ``` mod(number, divisor) ``` ``` number%divisor ``` ## Arguments (Argomenti) *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 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 `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 ``` netWorkDays(startDate, endDate) ``` ## Arguments (Argomenti) *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 Numero intero ## Valori di output 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 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 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 ``` now() ``` ## Tipo restituito Data # notIn `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 Utilizzando un elenco inserito manualmente: ``` notIn(expression, [literal-1, ...]) ``` Utilizzando un parametro multi-valore: ``` notIn(expression, $multivalue_parameter) ``` ## Arguments (Argomenti) *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 Valore booleano: TRUE/FALSE ## Esempio con un elenco inserito manualmente 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 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` `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 `nullIf` confronta due espressioni. Se sono uguali, la funzione restituisce null. Se non sono uguali, la funzione restituisce la prima espressione. ## Sintassi ``` nullIf(expression1, expression2) ``` ## Arguments (Argomenti) `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 Stringa ## Esempio 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 `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 ``` parseDate(expression, ['format']) ``` ## Arguments (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 **'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 Data ## Esempio 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 `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 ``` parseDecimal(expression) ``` ## Arguments (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 **'9.62'**, o una chiamata a un'altra funzione che genera una stringa. ## Tipo restituito Decimale (fisso) nell'esperienza di preparazione dei dati precedente. Decimal (Float) nella nuova esperienza di preparazione dei dati. ## Esempio 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 `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 ``` parseInt(expression) ``` ## Arguments (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 **'3'**, o una chiamata a un'altra funzione che genera una stringa. ## Tipo restituito Numero intero ## Esempio 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 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 ``` parseJson(fieldName, path) ``` ## Arguments (Argomenti) *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 Stringa ## Esempio 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 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 `replace` sostituisce parte di una stringa con un'altra stringa specificata. ## Sintassi ``` replace(expression, substring, replacement) ``` ## Arguments (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. *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 Stringa ## Esempio 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 `right` restituisce i caratteri più a destra di una stringa, inclusi gli spazi. Occorre specificare il numero di caratteri da restituire. ## Sintassi ``` right(expression, limit) ``` ## Arguments (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. *limite* Il numero di caratteri da recuperare da *espressione*, a partire dall'ultimo carattere della stringa. ## Tipo restituito Stringa ## Esempio 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 `round` arrotonda un valore decimale all'intero più vicino se non è specificata la dimensione oppure posizione decimale più vicina se la dimensione è specificata. ## Sintassi ``` round(decimal, scale) ``` ## Arguments (Argomenti) *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 | 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 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 `rtrim` rimuove lo spazio vuoto successivo da una stringa. ## Sintassi ``` rtrim(expression) ``` ## Arguments (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 Stringa ## Esempio 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 `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 ``` split(expression, delimiter , position) ``` ## Arguments (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;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 Array di stringhe ## Esempio 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 `sqrt` restituisce la radice quadrata di una determinata espressione. ## Sintassi ``` sqrt(expression) ``` ## Arguments (Argomenti) *espressione* L'espressione deve essere numerica. Può trattarsi di un nome di campo, un valore letterale o un'altra funzione. # startsWith `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 ``` startsWith(expression, substring, string-comparison-mode) ``` ## Arguments (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. *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 Booleano ## Esempi ### Esempio predefinito che distingue tra maiuscole e minuscole 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 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 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 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 I valori numerici possono essere utilizzati negli argomenti di espressioni o sottostringhe applicando la funzione `toString`. ``` startsWith(state_nm, toString(5) ) ``` # Strlen `strlen` restituisce il numero di caratteri in una stringa, inclusi gli spazi. ## Sintassi ``` strlen(expression) ``` ## Arguments (Argomenti) *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 Numero intero ## Esempio L'esempio seguente restituisce la lunghezza della stringa specificata. ``` strlen('1421 Main Street') ``` Viene restituito il valore seguente. ``` 16 ``` # Substring `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 ``` substring(expression, start, length) ``` ## Arguments (Argomenti) *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 Stringa ## Esempio 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 `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 ``` switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...], default-expression) ``` ## Arguments (Argomenti) `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 `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 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` 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 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 `toLower` formatta una stringa in tutte lettere minuscole. `toLower` ignora le righe che contengono valori null. ## Sintassi ``` toLower(expression) ``` ## Arguments (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 Stringa ## Esempio 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 `toString` formatta l'espressione immessa come stringa. `toString` ignora le righe che contengono valori null. ## Sintassi ``` toString(expression) ``` ## Arguments (Argomenti) *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 Stringa ## Esempio 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 `toUpper` formatta una stringa in tutte lettere maiuscole. `toUpper` ignora le righe che contengono valori null. ## Sintassi ``` toUpper(expression) ``` ## Arguments (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 Stringa ## Esempio 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 `trim` rimuove sia lo spazio vuoto precedente che quello successivo da una stringa. ## Sintassi ``` trim(expression) ``` ## Arguments (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 Stringa ## Esempio 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 `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 ``` truncDate('period', date) ``` ## Arguments (Argomenti) *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 Data ## Esempio 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 ```