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 matematiche Questa sezione descrive gli operatori e le funzioni matematiche supportati in AWS Clean Rooms Spark SQL. **Topics** + [Simboli degli operatori matematici](OPERATOR_SYMBOLS.md) + [Funzione ABS](ABS.md) + [Funzione ACOS](ACOS.md) + [Funzione ASIN](ASIN.md) + [Funzione ATAN](ATAN.md) + [ATAN2 funzione](ATAN2.md) + [Funzione CBRT](CBRT.md) + [Funzione CEILING (oppure CEIL)](CEILING_FLOOR.md) + [Funzione COS](COS.md) + [Funzione COT](COT.md) + [Funzione DEGREES](DEGREES.md) + [Funzione DIV](DIV.md) + [Funzione EXP](EXP.md) + [Funzione FLOOR](FLOOR.md) + [Funzione LN](LN.md) + [Funzione LOG](LOG.md) + [Funzione MOD](MOD.md) + [Funzione PI](PI.md) + [Funzione POWER](POWER.md) + [Funzioni RADIANS](RADIANS.md) + [Funzione RAND](RAND.md) + [Funzione RANDOM](RANDOM.md) + [Funzione ROUND](ROUND.md) + [Funzione SIGN](SIGN.md) + [Funzione SIN](SIN.md) + [Funzione SQRT](SQRT.md) + [Funzione TRUNC](TRUNC.md) # Simboli degli operatori matematici La tabella seguente elenca gli operatori matematici supportati. ## Operatori supportati [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/clean-rooms/latest/sql-reference/OPERATOR_SYMBOLS.html) ## Esempi Calcola la commissione pagata più una commissione di gestione di 2,00 USD per una determinata transazione: ``` select commission, (commission + 2.00) as comm from sales where salesid=10000; commission | comm -----------+------- 28.05 | 30.05 (1 row) ``` Calcolare il 20 percento del prezzo di vendita per una determinata transazione: ``` select pricepaid, (pricepaid * .20) as twentypct from sales where salesid=10000; pricepaid | twentypct ----------+----------- 187.00 | 37.400 (1 row) ``` Vendite di biglietti previste in base a un modello di crescita continua. In questo esempio, la sottoquery restituisce il numero di biglietti venduti nel 2008. Tale risultato viene moltiplicato in modo esponenziale per un tasso di crescita continuo del 5 percento in 10 anni. ``` select (select sum(qtysold) from sales, date where sales.dateid=date.dateid and year=2008) ^ ((5::float/100)*10) as qty10years; qty10years ------------------ 587.664019657491 (1 row) ``` Trova il prezzo totale pagato e le commissioni per le vendite con un ID data maggiore o uguale a 2.000. Quindi sottrarre la commissione totale dal prezzo totale pagato. ``` select sum (pricepaid) as sum_price, dateid, sum (commission) as sum_comm, (sum (pricepaid) - sum (commission)) as value from sales where dateid >= 2000 group by dateid order by dateid limit 10; sum_price | dateid | sum_comm | value -----------+--------+----------+----------- 364445.00 | 2044 | 54666.75 | 309778.25 349344.00 | 2112 | 52401.60 | 296942.40 343756.00 | 2124 | 51563.40 | 292192.60 378595.00 | 2116 | 56789.25 | 321805.75 328725.00 | 2080 | 49308.75 | 279416.25 349554.00 | 2028 | 52433.10 | 297120.90 249207.00 | 2164 | 37381.05 | 211825.95 285202.00 | 2064 | 42780.30 | 242421.70 320945.00 | 2012 | 48141.75 | 272803.25 321096.00 | 2016 | 48164.40 | 272931.60 (10 rows) ``` # Funzione ABS ABS calcola il valore assoluto di un numero, in cui quel numero può essere un valore letterale o un'espressione che valuta un numero. ## Sintassi ``` ABS (number) ``` ## Arguments (Argomenti) *numero* Numero o espressione che valuta un numero. Può essere SMALLINT, INTEGER, BIGINT, DECIMAL o type. FLOAT4 FLOAT8 ## Tipo restituito ABS Restituisce lo stesso tipo di dati del suo argomento. ## Esempi Calcolare il valore assoluto di -38: ``` select abs (-38); abs ------- 38 (1 row) ``` Calcolare il valore assoluto di (14-76): ``` select abs (14-76); abs ------- 62 (1 row) ``` # Funzione ACOS ACOS è una funzione trigonometrica che restituisce l'arco coseno di un numero. Il valore restituito è in radianti ed è compreso tra `0` e `PI`. ## Sintassi ``` ACOS(number) ``` ## Arguments (Argomenti) *numero* Il parametro di input è un numero `DOUBLE PRECISION`. ## Tipo restituito `DOUBLE PRECISION` ## Esempi Per restituire l'arco coseno di `-1`, utilizza l'esempio seguente. ``` SELECT ACOS(-1); +-------------------+ | acos | +-------------------+ | 3.141592653589793 | +-------------------+ ``` # Funzione ASIN ASIN è una funzione trigonometrica che restituisce l'arco seno di un numero. Il valore restituito è in radianti ed è compreso tra `PI/2` e `-PI/2`. ## Sintassi ``` ASIN(number) ``` ## Arguments (Argomenti) *numero* Il parametro di input è un numero `DOUBLE PRECISION`. ## Tipo restituito `DOUBLE PRECISION` ## Esempi Per restituire l'arco seno di `1`, utilizza l'esempio seguente. ``` SELECT ASIN(1) AS halfpi; +--------------------+ | halfpi | +--------------------+ | 1.5707963267948966 | +--------------------+ ``` # Funzione ATAN ATAN è una funzione trigonometrica che restituisce l'arco tangente di un numero. Il valore restituito è in radianti ed è compreso tra `-PI` e `PI`. ## Sintassi ``` ATAN(number) ``` ## Arguments (Argomenti) *numero* Il parametro di input è un numero `DOUBLE PRECISION`. ## Tipo restituito `DOUBLE PRECISION` ## Esempi Per restituire l'arco tangente di `1` e moltiplicarlo per 4, utilizza l'esempio seguente. ``` SELECT ATAN(1) * 4 AS pi; +-------------------+ | pi | +-------------------+ | 3.141592653589793 | +-------------------+ ``` # ATAN2 funzione ATAN2 è una funzione trigonometrica che restituisce l'arcotangente di un numero diviso per un altro numero. Il valore restituito è in radianti ed è compreso tra `PI/2` e `-PI/2`. ## Sintassi ``` ATAN2(number1, number2) ``` ## Arguments (Argomenti) *number1* Un numero `DOUBLE PRECISION`. *number2* Un numero `DOUBLE PRECISION`. ## Tipo restituito `DOUBLE PRECISION` ## Esempi Per restituire l'arco tangente di `2/2` e moltiplicarlo per 4, utilizza l'esempio seguente. ``` SELECT ATAN2(2,2) * 4 AS PI; +-------------------+ | pi | +-------------------+ | 3.141592653589793 | +-------------------+ ``` # Funzione CBRT La funzione CBRT è una funzione matematica che calcola la radice cubica di un numero. ## Sintassi ``` CBRT (number) ``` ## Argomento CBRT prende un numero DOUBLE PRECISION come argomento. ## Tipo restituito La funzione CBRT restituisce un numero DOUBLE PRECISION. ## Esempi Calcolare la radice cubica della commissione pagata per una determinata transazione: ``` select cbrt(commission) from sales where salesid=10000; cbrt ------------------ 3.03839539048843 (1 row) ``` # Funzione CEILING (oppure CEIL) La funzione CEILING o CEIL viene utilizzata per arrotondare un numero fino al numero intero successivo. (L [Funzione FLOOR](FLOOR.md) arrotonda un numero fino al numero intero successivo.) ## Sintassi ``` CEIL | CEILING(number) ``` ## Arguments (Argomenti) *numero* Il numero o l'espressione che restituisce un numero. Può essere SMALLINT, INTEGER, BIGINT, DECIMAL o type. FLOAT4 FLOAT8 ## Tipo restituito CEILING e CEIL restituiscono lo stesso tipo di dati come argomento. ## Esempio Calcolare il tetto della commissione pagata per una determinata transazione di vendita: ``` select ceiling(commission) from sales where salesid=10000; ceiling --------- 29 (1 row) ``` # Funzione COS COS è una funzione trigonometrica che restituisce il coseno di un numero. Il valore restituito è in radianti ed è compreso tra `-1` e `1`, inclusi. ## Sintassi ``` COS(double_precision) ``` ## Argomento *numero* Il parametro di input è un numero a precisione doppia. ## Tipo restituito La funzione COS restituisce un numero a precisione doppia. ## Esempi L'esempio seguente restituisce l'arco coseno di 0: ``` select cos(0); cos ----- 1 (1 row) ``` L'esempio seguente restituisce l'arco coseno di PI: ``` select cos(pi()); cos ----- -1 (1 row) ``` # Funzione COT COT è una funzione trigonometrica che restituisce la cotangente di un numero. Il parametro di input deve essere diverso da zero. ## Sintassi ``` COT(number) ``` ## Argomento *numero* Il parametro di input è un numero `DOUBLE PRECISION`. ## Tipo restituito `DOUBLE PRECISION` ## Esempi Per restituire la cotangente di 1, utilizza l'esempio seguente. ``` SELECT COT(1); +--------------------+ | cot | +--------------------+ | 0.6420926159343306 | +--------------------+ ``` # Funzione DEGREES Converte un angolo in radianti nel suo equivalente in gradi. ## Sintassi ``` DEGREES(number) ``` ## Argomento *numero* Il parametro di input è un numero `DOUBLE PRECISION`. ## Tipo restituito `DOUBLE PRECISION` ## Esempio Per restituire l'equivalente in gradi di 0,5 radianti, utilizza l'esempio seguente. ``` SELECT DEGREES(.5); +-------------------+ | degrees | +-------------------+ | 28.64788975654116 | +-------------------+ ``` Per convertire i radianti PI in gradi, utilizza l'esempio seguente. ``` SELECT DEGREES(pi()); +---------+ | degrees | +---------+ | 180 | +---------+ ``` # Funzione DIV L'operatore DIV restituisce la parte integrale della divisione del dividendo per divisore. ## Sintassi ``` dividend div divisor ``` ## Arguments (Argomenti) *dividendo* Un'espressione che restituisce un valore numerico o un intervallo. *divisore* Un tipo di intervallo corrispondente if `dividend` è un intervallo, altrimenti un valore numerico. ## Tipo restituito `BIGINT` ## Esempi L'esempio seguente seleziona due colonne dalla tabella degli scoiattoli: la `id` colonna, che contiene l'identificatore univoco per ogni scoiattolo, e una colonna`age div 2`, che rappresenta la divisione in numeri interi `calculated` della colonna dell'età per 2. Il `age div 2` calcolo esegue la divisione in numeri interi sulla `age` colonna, arrotondando efficacemente l'età al numero intero pari più vicino. Ad esempio, se la `age` colonna contiene valori come 3, 5, 7 e 10, la `age div 2` colonna conterrà rispettivamente i valori 1, 2, 3 e 5. ``` SELECT id, age div 2 FROM squirrels ``` Questa query può essere utile in scenari in cui è necessario raggruppare o analizzare i dati in base alle fasce di età e si desidera semplificare i valori di età arrotondandoli per difetto al numero intero pari più vicino. L'output risultante fornirebbe la `id` e l'età divisa per 2 per ogni scoiattolo nella tabella. `squirrels` # Funzione EXP La funzione EXP implementa la funzione esponenziale di un'espressione numerica o la base del logaritmo naturale, `e`, elevato alla potenza dell'espressione. La funzione EXP è l'inverso di [Funzione LN](LN.md). ## Sintassi ``` EXP (expression) ``` ## Argomento *espressione* L'espressione deve essere un tipo di dati numero INTEGER, DECIMAL, o DOUBLE PRECISION. ## Tipo restituito La funzione EXP restituisce un numero DOUBLE PRECISION. ## Esempio Utilizzare la funzione EXP per prevedere le vendite di biglietti in base a un modello di crescita continua. In questo esempio, la sottoquery restituisce il numero di biglietti venduti nel 2008. Questo risultato è moltiplicato per il risultato della funzione EXP, che specifica un tasso di crescita continua del 7% nel corso di 10 anni. ``` select (select sum(qtysold) from sales, date where sales.dateid=date.dateid and year=2008) * exp((7::float/100)*10) qty2018; qty2018 ------------------ 695447.483772222 (1 row) ``` # Funzione FLOOR La funzione FLOOR arrotonda un numero fino al numero intero successivo. ## Sintassi ``` FLOOR (number) ``` ## Argomento *numero* Il numero o l'espressione che restituisce un numero. Può essere SMALLINT, INTEGER, BIGINT, DECIMAL o type. FLOAT4 FLOAT8 ## Tipo restituito FLOOR restituisce lo stesso tipo di dati del suo argomento. ## Esempio L'esempio mostra il valore della commissione pagata per una determinata transazione di vendita prima e dopo l'utilizzo della funzione FLOOR. ``` select commission from sales where salesid=10000; floor ------- 28.05 (1 row) select floor(commission) from sales where salesid=10000; floor ------- 28 (1 row) ``` # Funzione LN La funzione LN restituisce il logaritmo naturale del parametro di input. ## Sintassi ``` LN(expression) ``` ## Argomento *espressione* L'espressione o colonna di destinazione su cui viene eseguita la funzione. Questa funzione restituisce un errore per alcuni tipi di dati se l'espressione fa riferimento a una tabella AWS Clean Rooms creata dall'utente o a una tabella di sistema AWS Clean Rooms STL o STV. Le espressioni con i seguenti tipi di dati generano un errore se fanno riferimento a una tabella creata dall'utente o di sistema. + BOOLEAN + CHAR + DATE + DECIMAL o NUMERIC + TIMESTAMP + VARCHAR Le espressioni con i seguenti tipi di dati vengono eseguite correttamente su tabelle create dall'utente e su tabelle di sistema STL o STV: + BIGINT + DOUBLE PRECISION + INTEGER + REAL + SMALLINT ## Tipo restituito La funzione LN restituisce lo stesso tipo dell'espressione. ## Esempio Nell'esempio seguente viene restituito il logaritmo naturale o il logaritmo di base e del numero 2,718281828: ``` select ln(2.718281828); ln -------------------- 0.9999999998311267 (1 row) ``` Si noti che la risposta è quasi uguale a 1. Questo esempio restituisce il logaritmo naturale dei valori nella colonna USERID nella tabella USERS: ``` select username, ln(userid) from users order by userid limit 10; username | ln ----------+------------------- JSG99FHE | 0 PGL08LJI | 0.693147180559945 IFT66TXU | 1.09861228866811 XDZ38RDD | 1.38629436111989 AEB55QTM | 1.6094379124341 NDQ15VBM | 1.79175946922805 OWY35QYB | 1.94591014905531 AZG78YIP | 2.07944154167984 MSD36KVR | 2.19722457733622 WKW41AIW | 2.30258509299405 (10 rows) ``` # Funzione LOG Restituisce il logaritmo di with. `expr` `base` ## Sintassi ``` LOG(base, expr) ``` ## Argomento *expr* L'espressione deve avere un tipo di dati integer, numero decimale o numero in virgola mobile. *base* La base per il calcolo del logaritmo. Deve essere un numero positivo (diverso da 1) di tipo di dati a doppia precisione. ## Tipo restituito La funzione LOG restituisce un numero a precisione doppia. ## Esempio Il seguente esempio restituisce il logaritmo di base 10 del numero 100: ``` select log(10, 100); -------- 2 (1 row) ``` # Funzione MOD Restituisce il resto di due numeri, altrimenti nota come operazione *modulo*. Per calcolare il risultato, il primo parametro viene diviso per il secondo. ## Sintassi ``` MOD(number1, number2) ``` ## Arguments (Argomenti) *number1* Il primo parametro di input è un numero INTEGER, SMALLINT, BIGINT, o DECIMAL. Se uno dei parametri è di tipo DECIMAL, anche l'altro parametro deve essere di tipo DECIMAL. Se uno dei parametri è un INTEGER, l'altro parametro può essere un INTEGER, SMALLINT, o BIGINT. Entrambi i parametri possono essere anche SMALLINT o BIGINT, ma un parametro non può essere un SMALLINT se l'altro è un BIGINT. *number2* Il secondo parametro di input è un numero INTEGER, SMALLINT, BIGINT, o DECIMAL. Le stesse regole sui tipi di dati si applicano a *number2* così come a *number1*. ## Tipo restituito I tipi di restituzione validi sono DECIMAL, INT, SMALLINT e BIGINT. Il tipo di restituzione della funzione MOD è lo stesso tipo numerico dei parametri di input, se entrambi i parametri di input sono dello stesso tipo. Se entrambi i parametri di input sono INTEGER, comunque, il tipo di restituzione sarà anche un INTEGER. ## Note per l'utilizzo Puoi utilizzare *%* come operatore di modulo. ## Esempi L'esempio seguente restituisce il resto quando un numero viene diviso per un altro: ``` SELECT MOD(10, 4); mod ------ 2 ``` L'esempio seguente restituisce un risultato decimale: ``` SELECT MOD(10.5, 4); mod ------ 2.5 ``` Puoi trasmettere i valori dei parametri: ``` SELECT MOD(CAST(16.4 as integer), 5); mod ------ 1 ``` Controlla se il primo parametro è pari dividendolo per 2: ``` SELECT mod(5,2) = 0 as is_even; is_even -------- false ``` Puoi utilizzare *%* come operatore di modulo: ``` SELECT 11 % 4 as remainder; remainder ----------- 3 ``` L'esempio seguente restituisce informazioni per le categorie dispari nella tabella CATEGORY: ``` select catid, catname from category where mod(catid,2)=1 order by 1,2; catid | catname -------+----------- 1 | MLB 3 | NFL 5 | MLS 7 | Plays 9 | Pop 11 | Classical (6 rows) ``` # Funzione PI La funzione PI restituisce il valore di pi con 14 posizioni decimali. ## Sintassi ``` PI() ``` ## Tipo restituito `DOUBLE PRECISION` ## Esempi Per restituire il valore di pi, utilizza l'esempio seguente. ``` SELECT PI(); +-------------------+ | pi | +-------------------+ | 3.141592653589793 | +-------------------+ ``` # Funzione POWER La funzione POWER è una funzione esponenziale che eleva un'espressione numerica alla potenza di una seconda espressione numerica. Ad esempio, 2 alla terza è calcolato come `POWER(2,3)`, con risultato `8`. ## Sintassi ``` {POWER(expression1, expression2) ``` ## Arguments (Argomenti) *expression1* Espressione numerica da elevare. Deve essere un tipo di dati `INTEGER`, `DECIMAL` o `FLOAT`. *expression2* Potenza da elevare *expression1*. Deve essere un tipo di dati `INTEGER`, `DECIMAL` o `FLOAT`. ## Tipo restituito `DOUBLE PRECISION` ## Esempio ``` SELECT (SELECT SUM(qtysold) FROM sales, date WHERE sales.dateid=date.dateid AND year=2008) * POW((1+7::FLOAT/100),10) qty2010; +-------------------+ | qty2010 | +-------------------+ | 679353.7540885945 | +-------------------+ ``` # Funzioni RADIANS La funzione RADIANS converte un angolo in gradi nel suo equivalente in radianti. ## Sintassi ``` RADIANS(number) ``` ## Argomento *numero* Il parametro di input è un numero `DOUBLE PRECISION`. ## Tipo restituito `DOUBLE PRECISION` ## Esempio Per restituire l'equivalente in radianti di 180 gradi, utilizza l'esempio seguente. ``` SELECT RADIANS(180); +-------------------+ | radians | +-------------------+ | 3.141592653589793 | +-------------------+ ``` # Funzione RAND La funzione RAND genera un numero casuale a virgola mobile compreso tra 0 e 1. La funzione RAND genera un nuovo numero casuale ogni volta che viene chiamata. ## Sintassi ``` RAND() ``` ## Tipo restituito RANDOM restituisce un valore DOUBLE. ## Esempio L'esempio seguente genera una colonna di numeri casuali a virgola mobile compresi tra 0 e 1 per ogni riga della tabella. `squirrels` L'output risultante sarebbe una singola colonna contenente un elenco di valori decimali casuali, con un valore per ogni riga della tabella degli scoiattoli. ``` SELECT rand() FROM squirrels ``` Questo tipo di query è utile quando è necessario generare numeri casuali, ad esempio per simulare eventi casuali o per introdurre la casualità nell'analisi dei dati. Nel contesto della `squirrels` tabella, potrebbe essere utilizzata per assegnare valori casuali a ciascuno scoiattolo, che potrebbero quindi essere utilizzati per ulteriori elaborazioni o analisi. # Funzione RANDOM La funzione RANDOM genera un valore casuale compreso tra 0.0 (incluso) e 1.0 (escluso). ## Sintassi ``` RANDOM() ``` ## Tipo restituito RANDOM restituisce un numero DOUBLE PRECISION. ## Esempi 1. Calcolare un valore casuale compreso tra 0 e 99. Se il numero casuale è da 0 a 1, questa query produce un numero casuale compreso tra 0 e 100: ``` select cast (random() * 100 as int); INTEGER ------ 24 (1 row) ``` 1. Recuperare un esempio casuale uniforme di 10 voci: ``` select * from sales order by random() limit 10; ``` Ora recuperare un esempio casuale di 10 voci, ma sceglierle in proporzione al loro prezzo. Ad esempio, una voce il cui prezzo è il doppio di un'altra ha il doppio delle probabilità di apparire nei risultati della query: ``` select * from sales order by log(1 - random()) / pricepaid limit 10; ``` 1. Questo esempio utilizza il comando SET per impostare un valore SEED in modo che RANDOM generi una sequenza di numeri prevedibile. Innanzitutto, restituisce tre interi RANDOM senza prima impostare il valore SEED: ``` select cast (random() * 100 as int); INTEGER ------ 6 (1 row) select cast (random() * 100 as int); INTEGER ------ 68 (1 row) select cast (random() * 100 as int); INTEGER ------ 56 (1 row) ``` Ora impostare il valore SEED su `.25`, e restituire altri tre numeri RANDOM: ``` set seed to .25; select cast (random() * 100 as int); INTEGER ------ 21 (1 row) select cast (random() * 100 as int); INTEGER ------ 79 (1 row) select cast (random() * 100 as int); INTEGER ------ 12 (1 row) ``` Infine, ripristinare il valore SEED su `.25`, e verificare che RANDOM restituisca gli stessi risultati delle tre chiamate precedenti: ``` set seed to .25; select cast (random() * 100 as int); INTEGER ------ 21 (1 row) select cast (random() * 100 as int); INTEGER ------ 79 (1 row) select cast (random() * 100 as int); INTEGER ------ 12 (1 row) ``` # Funzione ROUND La funzione ROUND arrotonda i numeri al integer o decimale più vicino. La funzione ROUND può facoltativamente includere un secondo argomento: un integer per indicare il numero di cifre decimali per l'arrotondamento, in entrambe le direzioni. Quando non si specifica il secondo argomento, la funzione viene arrotondata al numero intero più vicino. Quando il secondo argomento specificato è *>n*, la funzione viene arrotondata al numero più vicino con *n* cifre decimali di precisione. ## Sintassi ``` ROUND (number [ , integer ] ) ``` ## Argomento *numero* Un numero o un'espressione che restituisce un numero. Può essere DECIMAL o type. FLOAT8 AWS Clean Rooms può convertire altri tipi di dati secondo le regole di conversione implicite. *integer* (facoltativo) Un intero che indica il numero di posizioni decimali per l'arrotondamento, in entrambe le direzioni. ## Tipo restituito ROUND restituisce lo stesso tipo di dati numerici degli argomenti di input. ## Esempi Arrotondare la commissione pagata per una determinata transazione al numero intero più vicino. ``` select commission, round(commission) from sales where salesid=10000; commission | round -----------+------- 28.05 | 28 (1 row) ``` Arrotondare la commissione pagata per una determinata transazione al primo posto decimale. ``` select commission, round(commission, 1) from sales where salesid=10000; commission | round -----------+------- 28.05 | 28.1 (1 row) ``` Per la stessa query, estendere la precisione nella direzione opposta. ``` select commission, round(commission, -1) from sales where salesid=10000; commission | round -----------+------- 28.05 | 30 (1 row) ``` # Funzione SIGN La funzione SIGN restituisce il segno (positivo o negativo) di un numero. Il risultato della funzione SIGN è un valore `1`, `-1` o `0` a indicare il segno dell'argomento. ## Sintassi ``` SIGN (number) ``` ## Argomento *numero* Numero o espressione che valuta un numero. Può essere il DECIMALor FLOAT8 tipo. AWS Clean Rooms può convertire altri tipi di dati secondo le regole di conversione implicite. ## Tipo restituito SIGN restituisce lo stesso tipo di dati numerici degli argomenti di input. Se l'input è DECIMAL, l'output è DECIMAL(1,0). ## Esempi Per determinare il segno della commissione pagata per una determinata transazione dalla tabella SALES, utilizza l'esempio seguente. ``` SELECT commission, SIGN(commission) FROM sales WHERE salesid=10000; +------------+------+ | commission | sign | +------------+------+ | 28.05 | 1 | +------------+------+ ``` # Funzione SIN SIN è una funzione trigonometrica che restituisce il seno di un numero. Il valore restituito è compreso tra `-1` e `1`. ## Sintassi ``` SIN(number) ``` ## Argomento *numero* Un numero `DOUBLE PRECISION` in radianti. ## Tipo restituito `DOUBLE PRECISION` ## Esempio Per restituire il seno di `-PI`, utilizza l'esempio seguente. ``` SELECT SIN(-PI()); +-------------------------+ | sin | +-------------------------+ | -0.00000000000000012246 | +-------------------------+ ``` # Funzione SQRT La funzione SQRT restituisce la radice quadrata di un valore numerico. La radice quadrata è un numero moltiplicato per sé stesso per ottenere il valore fornito. ## Sintassi ``` SQRT (expression) ``` ## Argomento *espressione* L'espressione deve avere un tipo di dati integer, numero decimale o numero in virgola mobile. L'espressione può includere funzioni. Il sistema potrebbe eseguire conversioni di tipo implicito. ## Tipo restituito La funzione SQRT restituisce un numero DOUBLE PRECISION. ## Esempi L'esempio seguente restituisce la radice quadrata di un numero. ``` select sqrt(16); sqrt --------------- 4 ``` L'esempio seguente esegue una conversione di tipo implicito. ``` select sqrt('16'); sqrt --------------- 4 ``` L'esempio seguente annida le funzioni per eseguire un'attività più complessa. ``` select sqrt(round(16.4)); sqrt --------------- 4 ``` L'esempio seguente restituisce la lunghezza del raggio quando viene fornita l'area di un cerchio. Calcola il raggio in pollici, ad esempio, quando viene fornita l'area in pollici quadrati. L'area dell'esempio è 20. ``` select sqrt(20/pi()); ``` Ciò restituisce il valore 5,046265044040321. L'esempio seguente restituisce la radice quadrata per i valori di COMMISSION dalla tabella SALES. La colonna COMMISSION è una colonna DECIMAL. Questo esempio mostra come utilizzare la funzione in una query con una logica condizionale più complessa. ``` select sqrt(commission) from sales where salesid < 10 order by salesid; sqrt ------------------ 10.4498803820905 3.37638860322683 7.24568837309472 5.1234753829798 ... ``` La seguente query restituisce la radice quadrata arrotondata per lo stesso insieme dei valori di COMMISSION. ``` select salesid, commission, round(sqrt(commission)) from sales where salesid < 10 order by salesid; salesid | commission | round --------+------------+------- 1 | 109.20 | 10 2 | 11.40 | 3 3 | 52.50 | 7 4 | 26.25 | 5 ... ``` Per ulteriori informazioni sui dati di esempio in AWS Clean Rooms, consulta [Database di esempio](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html). # Funzione TRUNC La funzione TRUNC tronca i numeri all'intero o al decimale precedente. La funzione TRUNC può facoltativamente includere un secondo argomento come un intero per indicare il numero di cifre decimali per l'arrotondamento, in entrambe le direzioni. Quando non si specifica il secondo argomento, la funzione viene arrotondata al numero intero più vicino. Quando viene specificato il secondo argomento *>n*, la funzione viene arrotondata al numero più vicino con *n* cifre decimali di precisione. Questa funzione tronca anche un timestamp e restituisce una data. ## Sintassi ``` TRUNC (number [ , integer ] | timestamp ) ``` ## Arguments (Argomenti) *numero* Un numero o un'espressione che restituisce un numero. Può essere il numero DECIMALE o FLOAT8 il tipo. AWS Clean Rooms può convertire altri tipi di dati secondo le regole di conversione implicite. *integer* (facoltativo) Un integer che indica il numero di posizioni decimali di precisione, in entrambe le direzioni. Se non viene fornito un valore integer, il numero viene troncato come numero intero; se viene specificato un valore integer, il numero viene troncato alla posizione decimale specificata. *timestamp* La funzione può anche restituire la data da un timestamp. Per restituire un valore di timestamp con `00:00:00` come ora, eseguire il casting del risultato della funzione su TIMESTAMP. ## Tipo restituito TRUNC restituisce lo stesso tipo di dati del primo argomento di input. Per i timestamp, TRUNC restituisce una data. ## Esempi Troncare la commissione pagata per una determinata transazione di vendita. ``` select commission, trunc(commission) from sales where salesid=784; commission | trunc -----------+------- 111.15 | 111 (1 row) ``` Troncare lo stesso valore della commissione alla prima posizione decimale. ``` select commission, trunc(commission,1) from sales where salesid=784; commission | trunc -----------+------- 111.15 | 111.1 (1 row) ``` Troncare la commissione con un valore negativo per il secondo argomento; `111.15` è arrotondato per difetto a `110`. ``` select commission, trunc(commission,-1) from sales where salesid=784; commission | trunc -----------+------- 111.15 | 110 (1 row) ``` Restituisce la parte di data dal risultato della funzione SYSDATE (che restituisce un timestamp): ``` select sysdate; timestamp ---------------------------- 2011-07-21 10:32:38.248109 (1 row) select trunc(sysdate); trunc ------------ 2011-07-21 (1 row) ``` Applica la funzione TRUNC a una colonna TIMESTAMP. Il tipo restituito è una data. ``` select trunc(starttime) from event order by eventid limit 1; trunc ------------ 2008-01-25 (1 row) ```