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à.
# AWS Clean Rooms Funzioni Spark SQL
AWS Clean Rooms Spark SQL supporta le seguenti funzioni SQL:
**Topics**
+ [Funzioni di aggregazione](sql-functions-agg-spark.md)
+ [Funzioni di array](Array_Functions.md)
+ [Espressioni condizionali](sql-functions-conditional-expressions-spark.md)
+ [Funzioni costruttore](sql-functions-constructor.md)
+ [Funzioni di formattazione del tipo di dati](Data_type_formatting.md)
+ [Funzioni di data e ora](date-time-functions-spark.md)
+ [Funzioni di crittografia e decrittografia](encryption-decryption-functions.md)
+ [Funzioni hash](s_hash-functions.md)
+ [Funzioni Hyperloglog](hyperloglog-functions.md)
+ [Funzioni JSON](json-functions-spark.md)
+ [Funzioni matematiche](Math_functions-spark.md)
+ [Funzioni scalari](scalar_functions.md)
+ [Funzioni stringa](String_functions_spark.md)
+ [Funzioni relative alla privacy](privacy-related-functions.md)
+ [Funzioni finestra](Window_functions.md)
# Funzioni di aggregazione
Le funzioni aggregate in AWS Clean Rooms Spark SQL vengono utilizzate per eseguire calcoli o operazioni su un gruppo di righe e restituire un singolo valore. Sono essenziali per le attività di analisi e riepilogo dei dati.
AWS Clean Rooms Spark SQL supporta le seguenti funzioni di aggregazione:
**Topics**
+ [Funzione ANY\$1VALUE](ANY_VALUE.md)
+ [Funzione APPROX COUNT\$1DISTINCT](approx-count-distinct.md)
+ [Funzione APPROX PERCENTILE](approx-percentile.md)
+ [Funzione AVG](avg-function.md)
+ [Funzione BOOL\$1AND](BOOL_AND.md)
+ [Funzione BOOL\$1OR](BOOL_OR.md)
+ [Funzione CARDINALITY](CARDINALITY.md)
+ [Funzione COLLECT\$1LIST](COLLECT_LIST.md)
+ [Funzione COLLECT\$1SET](COLLECT_SET.md)
+ [COUNTe funzioni COUNT DISTINCT](count-function.md)
+ [Funzione COUNT](COUNT.md)
+ [Funzione MAX](MAX.md)
+ [Funzione MEDIAN](MEDIAN.md)
+ [Funzione MIN](MIN.md)
+ [Funzione PERCENTILE](percentile.md)
+ [Funzione SKEWNESS](SKEWNESS.md)
+ [Funzioni STDDEV\$1SAMP e STDDEV\$1POP](STDDEV_functions.md)
+ [SUMe funzioni SUM DISTINCT](sum-function.md)
+ [Funzioni VAR\$1SAMP e VAR\$1POP](VARIANCE_functions.md)
# Funzione ANY\$1VALUE
La funzione ANY\$1VALUE restituisce qualsiasi valore dai valori dell'espressione di input in modo non deterministico. Questa funzione può restituire NULL se l'espressione di input non determina la restituzione di righe.
## Sintassi
```
ANY_VALUE (expression[, isIgnoreNull] )
```
## Arguments (Argomenti)
*expression *
L'espressione o la colonna di destinazione su cui viene eseguita la funzione. L'*espressione* è uno dei seguenti tipi di dati:
*isIgnoreNull*
Un valore booleano che determina se la funzione deve restituire solo valori non nulli.
## Valori restituiti
Restituisce lo stesso tipo di dati come *espressione*.
## Note per l’utilizzo
Se un'istruzione che specifica la funzione ANY\$1VALUE per una colonna include anche un riferimento a una secondo colonna, la seconda colonna deve essere visualizzata in una clausola GROUP BY o inclusa in una funzione di aggregazione.
## Esempi
L'esempio seguente restituisce un'istanza di any `dateid` where the is. `eventname` `Eagles`
```
select any_value(dateid) as dateid, eventname from event where eventname ='Eagles' group by eventname;
```
Di seguito sono riportati i risultati.
```
dateid | eventname
-------+---------------
1878 | Eagles
```
L'esempio seguente restituisce un'istanza di any `dateid` where the `eventname` is `Eagles` or`Cold War Kids`.
```
select any_value(dateid) as dateid, eventname from event where eventname in('Eagles', 'Cold War Kids') group by eventname;
```
Di seguito sono riportati i risultati.
```
dateid | eventname
-------+---------------
1922 | Cold War Kids
1878 | Eagles
```
# Funzione APPROX COUNT\$1DISTINCT
APPROX COUNT\$1DISTINCT fornisce un modo efficiente per stimare il numero di valori univoci in una colonna o in un set di dati.
## Sintassi
```
approx_count_distinct(expr[, relativeSD])
```
## Arguments (Argomenti)
*expr*
L'espressione o la colonna per cui si desidera stimare il numero di valori univoci.
Può essere una singola colonna, un'espressione complessa o una combinazione di colonne.
*Relative D*
Un parametro opzionale che specifica la deviazione standard relativa desiderata della stima.
È un valore compreso tra 0 e 1, che rappresenta l'errore relativo massimo accettabile della stima. Un valore RelativeD inferiore darà come risultato una stima più accurata ma più lenta.
Se questo parametro non viene fornito, viene utilizzato un valore predefinito (in genere intorno a 0,05 o 5%).
## Valori restituiti
Restituisce la cardinalità stimata in HyperLogLog \$1\$1. relativeSD definisce la deviazione standard relativa massima consentita.
## Esempio
La seguente query stima il numero di valori univoci nella `col1` colonna, con una deviazione standard relativa dell'1% (0,01).
```
SELECT approx_count_distinct(col1, 0.01)
```
La seguente query stima che nella `col1` colonna siano presenti 3 valori univoci (i valori 1, 2 e 3).
```
SELECT approx_count_distinct(col1) FROM VALUES (1), (1), (2), (2), (3) tab(col1)
```
# Funzione APPROX PERCENTILE
APPROX PERCENTILE viene utilizzato per stimare il valore percentile di una determinata espressione o colonna senza dover ordinare l'intero set di dati. Questa funzione è utile in scenari in cui è necessario comprendere rapidamente la distribuzione di un set di dati di grandi dimensioni o tenere traccia delle metriche basate sui percentili, senza il sovraccarico computazionale dovuto all'esecuzione di un calcolo percentile esatto. Tuttavia, è importante comprendere i compromessi tra velocità e precisione e scegliere la tolleranza di errore appropriata in base ai requisiti specifici del caso d'uso.
## Sintassi
```
APPROX_PERCENTILE(expr, percentile [, accuracy])
```
## Arguments (Argomenti)
*expr*
L'espressione o la colonna per cui si desidera stimare il valore del percentile.
Può essere una singola colonna, un'espressione complessa o una combinazione di colonne.
*percentile*
Il valore percentile da stimare, espresso come valore compreso tra 0 e 1.
Ad esempio, 0,5 corrisponderebbe al 50° percentile (mediana).
*precisione*
Un parametro opzionale che specifica la precisione desiderata della stima del percentile. È un valore compreso tra 0 e 1, che rappresenta l'errore relativo massimo accettabile della stima. Un `accuracy` valore inferiore darà come risultato una stima più precisa ma più lenta. Se questo parametro non viene fornito, viene utilizzato un valore predefinito (in genere intorno allo 0,05 o al 5%).
## Valori restituiti
Restituisce il percentile approssimativo della colonna numerica o dell'intervallo ANSI col, che è il valore più piccolo tra i valori col ordinati (ordinati dal minimo al più grande) in modo che non più della percentuale dei valori col sia inferiore o uguale a tale valore.
Il valore della percentuale deve essere compreso tra 0,0 e 1,0. Il parametro di precisione (predefinito: 10000) è un valore letterale numerico positivo che controlla la precisione dell'approssimazione a scapito della memoria.
Un valore di precisione più elevato produce una migliore precisione, `1.0/accuracy` è l'errore relativo dell'approssimazione.
Quando la percentuale è una matrice, ogni valore della matrice percentuale deve essere compreso tra 0,0 e 1,0. In questo caso, restituisce l'array percentile approssimativo della colonna col nella matrice percentuale specificata.
## Esempi
La seguente query stima il 95° percentile della `response_time` colonna, con un errore relativo massimo dell'1% (0,01).
```
SELECT APPROX_PERCENTILE(response_time, 0.95, 0.01) AS p95_response_time
FROM my_table;
```
La seguente query stima i valori del 50°, 40° e 10° percentile della colonna della tabella. `col` `tab`
```
SELECT approx_percentile(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col)
```
La seguente query stima il 50° percentile (mediano) dei valori nella colonna col.
```
SELECT approx_percentile(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col)
```
# Funzione AVG
La AVG funzione restituisce la media (media aritmetica) dei valori delle espressioni di input. La AVG funzione funziona con valori numerici e ignora i valori NULL.
## Sintassi
```
AVG (column)
```
## Arguments (Argomenti)
*column*
La colonna di destinazione su cui opera la funzione. La colonna è uno dei seguenti tipi di dati:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ DOUBLE
+ FLOAT
## Tipi di dati
I tipi di argomento supportati dalla AVG funzione sono SMALLINTINTEGER,BIGINT,DECIMAL, eDOUBLE.
I tipi di ritorno supportati dalla AVG funzione sono:
+ BIGINTper qualsiasi argomento di tipo intero
+ DOUBLEper un argomento in virgola mobile
+ Restituisce lo stesso tipo di dati dell'espressione per qualsiasi altro tipo di argomento
La precisione predefinita per il risultato di una AVG funzione con un DECIMAL argomento è 38. Il ridimensionamento del risultato coincide con il ridimensionamento dell'argomento. Ad esempio, un elemento AVG di una DEC(5,2) colonna restituisce un tipo di DEC(38,2) dati.
## Esempio
Trova la quantità media venduta per transazione dalla SALES tabella.
```
select avg(qtysold) from sales;
```
# Funzione BOOL\$1AND
La funzione BOOL\$1AND opera su una singola colonna o espressione booleana o intera. Questa funzione applica una logica simile alle funzioni BIT\$1AND e BIT\$1OR. Per questa funzione, il tipo restituito è un valore booleano (`true` o `false`).
Se tutti i valori in un insieme sono veri, viene restituita la funzione BOOL\$1AND `true` (`t`). Se un valore è falso, la funzione restituisce `false` (`f`).
## Sintassi
```
BOOL_AND ( [DISTINCT | ALL] expression )
```
## Arguments (Argomenti)
*expression *
L'espressione o colonna di destinazione su cui viene eseguita la funzione. Questa espressione deve avere un tipo di dati intero o BOOLEAN. Il tipo restituito della funzione è BOOLEAN.
DISTINCT \$1 ALL
Con l'argomento DISTINCT, la funzione elimina tutti i valori duplicati per l'espressione specificata prima di calcolare il risultato. Con l'argomento ALL, la funzione mantiene tutti i valori duplicati. ALL è il valore predefinito.
## Esempi
È possibile utilizzare le funzioni booleane rispetto alle espressioni booleane o alle espressioni intere.
Ad esempio, la seguente query restituisce i risultati dalla tabella USERS standard nel database TICKIT, che ha diverse colonne booleane.
La funzione BOOL\$1AND restituisce `false` per tutte e cinque le righe. Non a tutti gli utenti in ciascuno di questi stati piace lo sport.
```
select state, bool_and(likesports) from users
group by state order by state limit 5;
state | bool_and
------+---------
AB | f
AK | f
AL | f
AZ | f
BC | f
(5 rows)
```
# Funzione BOOL\$1OR
La funzione BOOL\$1OR opera su una singola colonna o espressione booleana o intera. Questa funzione applica una logica simile alle funzioni BIT\$1AND e BIT\$1OR. Per questa funzione, il tipo restituito è un valore booleano (`true`, `false` o `NULL`).
Se un valore in un insieme è `true`, la funzione BOOL\$1OR restituisce `true` (`t`). Se un valore in un insieme è `false`, la funzione restituisce `false` (`f`). NULL può essere restituito se il valore è sconosciuto.
## Sintassi
```
BOOL_OR ( [DISTINCT | ALL] expression )
```
## Arguments (Argomenti)
*expression *
L'espressione o colonna di destinazione su cui viene eseguita la funzione. Questa espressione deve avere un tipo di dati intero o BOOLEAN. Il tipo restituito della funzione è BOOLEAN.
DISTINCT \$1 ALL
Con l'argomento DISTINCT, la funzione elimina tutti i valori duplicati per l'espressione specificata prima di calcolare il risultato. Con l'argomento ALL, la funzione mantiene tutti i valori duplicati. ALL è il valore predefinito.
## Esempi
È possibile utilizzare le funzioni booleane rispetto alle espressioni booleane o alle espressioni intere. Ad esempio, la seguente query restituisce i risultati dalla tabella USERS standard nel database TICKIT, che ha diverse colonne booleane.
La funzione BOOL\$1OR restituisce `true` per tutte e cinque le righe. Ad almeno un utente in ciascuno di questi stati piace lo sport.
```
select state, bool_or(likesports) from users
group by state order by state limit 5;
state | bool_or
------+--------
AB | t
AK | t
AL | t
AZ | t
BC | t
(5 rows)
```
Il seguente esempio restituisce NULL.
```
SELECT BOOL_OR(NULL = '123')
bool_or
------
NULL
```
# Funzione CARDINALITY
*La funzione CARDINALITY restituisce la dimensione di un'espressione ARRAY o MAP (expr).*
Questa funzione è utile per trovare la dimensione o la lunghezza di un array.
## Sintassi
```
cardinality(expr)
```
## Arguments (Argomenti)
*expr*
Un'espressione ARRAY o MAP.
## Valori restituiti
Restituisce la dimensione di un array o di una mappa (INTEGER).
La funzione restituisce `NULL` un input nullo se `sizeOfNull` è impostata su `false` o `enabled` è impostata su. `true`
Altrimenti, la funzione restituisce un `-1` input nullo. Con le impostazioni predefinite, la funzione restituisce un `-1` input nullo.
## Esempio
La seguente query calcola la cardinalità, o il numero di elementi, nell'array dato. L'array (`'b', 'd', 'c', 'a'`) ha 4 elementi, quindi l'output di questa query sarebbe. `4`
```
SELECT cardinality(array('b', 'd', 'c', 'a'));
4
```
# Funzione COLLECT\$1LIST
La funzione COLLECT\$1LIST raccoglie e restituisce un elenco di elementi non unici.
Questo tipo di funzione è utile quando si desidera raccogliere più valori da un insieme di righe in una singola matrice o struttura di dati di elenco.
**Nota**
La funzione non è deterministica perché l'ordine dei risultati raccolti dipende dall'ordine delle righe, che può essere non deterministico dopo l'esecuzione di un'operazione di shuffle.
## Sintassi
```
collect_list(expr)
```
## Arguments (Argomenti)
*expr*
Un'espressione di qualsiasi tipo.
## Valori restituiti
Restituisce un ARRAY del tipo di argomento. L'ordine degli elementi nell'array non è deterministico.
I valori NULL sono esclusi.
Se viene specificato DISTINCT, la funzione raccoglie solo valori univoci ed è sinonimo di funzione aggregata. `collect_set `
## Esempio
La seguente query raccoglie tutti i valori dalla colonna col in un elenco. La `VALUES` clausola viene utilizzata per creare una tabella in linea con tre righe, in cui ogni riga ha una singola colonna con i valori 1, 2 e 1 rispettivamente. La `collect_list() ` funzione viene quindi utilizzata per aggregare tutti i valori della colonna col in un unico array. L'output di questa istruzione SQL sarebbe l'array`[1,2,1]`, che contiene tutti i valori della colonna col nell'ordine in cui sono apparsi nei dati di input.
```
SELECT collect_list(col) FROM VALUES (1), (2), (1) AS tab(col);
[1,2,1]
```
# Funzione COLLECT\$1SET
La funzione COLLECT\$1SET raccoglie e restituisce un set di elementi unici.
Questa funzione è utile quando si desidera raccogliere tutti i valori distinti da un insieme di righe in un'unica struttura di dati, senza includere duplicati.
**Nota**
La funzione non è deterministica perché l'ordine dei risultati raccolti dipende dall'ordine delle righe, che può essere non deterministico dopo l'esecuzione di un'operazione di shuffle.
## Sintassi
```
collect_set(expr)
```
## Arguments (Argomenti)
*expr*
Un'espressione di qualsiasi tipo tranne MAP.
## Valori restituiti
Restituisce un ARRAY del tipo di argomento. L'ordine degli elementi nell'array non è deterministico.
I valori NULL sono esclusi.
## Esempio
La seguente query raccoglie tutti i valori univoci dalla colonna col in un set. La `VALUES` clausola viene utilizzata per creare una tabella in linea con tre righe, in cui ogni riga ha una singola colonna con i valori 1, 2 e 1 rispettivamente. La `collect_set()` funzione viene quindi utilizzata per aggregare tutti i valori univoci della colonna col in un unico set. L'output di questa istruzione SQL sarebbe il set`[1,2]`, che contiene i valori univoci della colonna col. Il valore duplicato di 1 viene incluso una sola volta nel risultato.
```
SELECT collect_set(col) FROM VALUES (1), (2), (1) AS tab(col);
[1,2]
```
# COUNTe funzioni COUNT DISTINCT
La COUNT funzione conta le righe definite dall'espressione. La COUNT DISTINCT funzione calcola il numero di valori distinti non NULL in una colonna o in un'espressione. Elimina tutti i valori duplicati dall'espressione specificata prima di eseguire il conteggio.
## Sintassi
```
COUNT (DISTINCT column)
```
## Arguments (Argomenti)
*column*
La colonna di destinazione su cui opera la funzione.
## Tipi di dati
La COUNT funzione e la COUNT DISTINCT funzione supportano tutti i tipi di dati degli argomenti.
La COUNT DISTINCT funzione restituisceBIGINT.
## Esempi
Conta tutti gli utenti dello stato della Florida.
```
select count (identifier) from users where state='FL';
```
Conta tutti i locali unici IDs visti dalla EVENT tabella.
```
select count (distinct venueid) as venues from event;
```
# Funzione COUNT
La funzione COUNT conta le righe definite dall'espressione.
La funzione COUNT ha le seguenti variazioni.
+ COUNT ( \$1 ) conta tutte le righe nella tabella di destinazione indipendentemente dal fatto che includano valori null o meno.
+ COUNT ( *espressione* ) calcola il numero di righe con valori non NULL in una colonna o espressione specifica.
+ COUNT ( DISTINCT *espressione* ) calcola il numero di valori distinti non NULL in una colonna o espressione.
## Sintassi
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] expression )
```
## Arguments (Argomenti)
*expression *
L'espressione o colonna di destinazione su cui viene eseguita la funzione. La funzione COUNT supporta tutti i tipi di dati degli argomenti.
DISTINCT \$1 ALL
Con l'argomento DISTINCT, la funzione elimina tutti i valori duplicati dall'espressione specificata prima di eseguire il conteggio. Con l'argomento ALL, la funzione mantiene tutti i valori duplicati dall'espressione per il conteggio. ALL è il valore predefinito.
## Tipo restituito
La funzione COUNT restituisce BIGINT.
## Esempi
Calcolare tutti gli utenti provenienti dallo stato della Florida:
```
select count(*) from users where state='FL';
count
-------
510
```
Calcolare tutti i nomi degli eventi dalla tabella EVENT:
```
select count(eventname) from event;
count
-------
8798
```
Calcolare tutti i nomi degli eventi dalla tabella EVENT:
```
select count(all eventname) from event;
count
-------
8798
```
Conta tutti i luoghi unici presenti IDs nella tabella EVENT:
```
select count(distinct venueid) as venues from event;
venues
--------
204
```
Contare il numero di volte in cui ciascun venditore ha elencato lotti di oltre quattro biglietti in vendita. Raggruppare i risultati per ID venditore:
```
select count(*), sellerid from listing
where numtickets > 4
group by sellerid
order by 1 desc, 2;
count | sellerid
------+----------
12 | 6386
11 | 17304
11 | 20123
11 | 25428
...
```
# Funzione MAX
La funzione MAX restituisce il valore massimo in un insieme di righe. È possibile utilizzare DISTINCT oppure ALL ma non influenzano il risultato.
## Sintassi
```
MAX ( [ DISTINCT | ALL ] expression )
```
## Arguments (Argomenti)
*expression *
L'espressione o colonna di destinazione su cui viene eseguita la funzione. L'*espressione* è qualsiasi tipo di dato numerico.
DISTINCT \$1 ALL
Con l'argomento DISTINCT, la funzione elimina tutti i valori duplicati dall'espressione specificata prima di calcolare il massimo. Con l'argomento ALL, la funzione mantiene tutti i valori duplicati dall'espressione per calcolare il massimo. ALL è il valore predefinito.
## Tipi di dati
Restituisce lo stesso tipo di dati come *espressione*.
## Esempi
Trovare il prezzo più alto pagato da tutte le vendite:
```
select max(pricepaid) from sales;
max
----------
12624.00
(1 row)
```
Trovare il prezzo più alto pagato per biglietto da tutte le vendite:
```
select max(pricepaid/qtysold) as max_ticket_price
from sales;
max_ticket_price
-----------------
2500.00000000
(1 row)
```
# Funzione MEDIAN
## Sintassi
```
MEDIAN ( median_expression )
```
## Arguments (Argomenti)
*median\$1expression*
L'espressione o colonna di destinazione su cui viene eseguita la funzione.
# Funzione MIN
La funzione MIN restituisce il valore minimo in un insieme di righe. È possibile utilizzare DISTINCT oppure ALL ma non influenzano il risultato.
## Sintassi
```
MIN ( [ DISTINCT | ALL ] expression )
```
## Arguments (Argomenti)
*expression *
L'espressione o colonna di destinazione su cui viene eseguita la funzione. L'*espressione* è un tipo di dati numerico qualsiasi.
DISTINCT \$1 ALL
Con l'argomento DISTINCT, la funzione elimina tutti i valori duplicati dall'espressione specificata prima di calcolare il minimo. Con l'argomento ALL, la funzione mantiene tutti i valori duplicati dall'espressione per calcolare il minimo. ALL è il valore predefinito.
## Tipi di dati
Restituisce lo stesso tipo di dati come *espressione*.
## Esempi
Trovare il prezzo più basso pagato da tutte le vendite:
```
select min(pricepaid) from sales;
min
-------
20.00
(1 row)
```
Trovare il prezzo più basso pagato per biglietto da tutte le vendite:
```
select min(pricepaid/qtysold)as min_ticket_price
from sales;
min_ticket_price
------------------
20.00000000
(1 row)
```
# Funzione PERCENTILE
La funzione PERCENTILE viene utilizzata per calcolare il valore percentile esatto ordinando prima i valori nella `col` colonna e poi trovando il valore nel valore specificato. `percentage`
La funzione PERCENTILE è utile quando è necessario calcolare il valore percentile esatto e il costo computazionale è accettabile per il caso d'uso. Fornisce risultati più accurati rispetto alla funzione APPROX\$1PERCENTILE, ma può essere più lenta, specialmente per set di dati di grandi dimensioni.
Al contrario, la funzione APPROX\$1PERCENTILE è un'alternativa più efficiente in grado di fornire una stima del valore del percentile con una tolleranza di errore specificata, il che la rende più adatta per scenari in cui la velocità ha una priorità maggiore rispetto alla precisione assoluta.
## Sintassi
```
percentile(col, percentage [, frequency])
```
## Arguments (Argomenti)
*col*
L'espressione o la colonna per cui si desidera calcolare il valore del percentile.
*percentuale*
Il valore percentile da calcolare, espresso come valore compreso tra 0 e 1.
Ad esempio, 0,5 corrisponderebbe al 50° percentile (mediana).
*frequenza*
Un parametro opzionale che specifica la frequenza o il peso di ogni valore nella `col` colonna. Se fornito, la funzione calcolerà il percentile in base alla frequenza di ciascun valore.
## Valori restituiti
Restituisce il valore percentile esatto della colonna numerica o dell'intervallo ANSI col alla percentuale specificata.
Il valore della percentuale deve essere compreso tra 0,0 e 1,0.
Il valore della frequenza deve essere un integrale positivo
## Esempio
La seguente query trova il valore maggiore o uguale al 30% dei valori nella `col` colonna. Poiché i valori sono 0 e 10, il 30° percentile è 3,0, poiché è il valore maggiore o uguale al 30% dei dati.
```
SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);
3.0
```
# Funzione SKEWNESS
La funzione SKEWNESS restituisce il valore di asimmetria calcolato in base ai valori di un gruppo.
L'asimmetria è una misura statistica che descrive l'asimmetria o la mancanza di simmetria in un set di dati. Fornisce informazioni sulla forma della distribuzione dei dati.
Questa funzione può essere utile per comprendere le proprietà statistiche di un set di dati e fornire informazioni per ulteriori analisi o processi decisionali.
## Sintassi
```
skewness(expr)
```
## Arguments (Argomenti)
*expr*
Un'espressione che restituisce un valore numerico.
## Valori restituiti
Restituisce DOUBLE.
Se viene specificato DISTINCT, la funzione opera solo su un set univoco di valori *expr.*
## Esempi
La seguente query calcola l'asimmetria dei valori nella colonna. `col` In questo esempio, la `VALUES` clausola viene utilizzata per creare una tabella in linea con quattro righe, in cui ogni riga ha una singola colonna `col` con i valori -10, -20, 100 e 1000. La `skewness()` funzione viene quindi utilizzata per calcolare l'asimmetria dei valori nella colonna. `col` Il risultato, 1.1135657469022011, rappresenta il grado e la direzione dell'asimmetria nei dati. Un valore di asimmetria positivo indica che i dati sono inclinati verso destra, con la maggior parte dei valori concentrati sul lato sinistro della distribuzione. Un valore di asimmetria negativo indica che i dati sono inclinati verso sinistra, con la maggior parte dei valori concentrati sul lato destro della distribuzione.
```
SELECT skewness(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
1.1135657469022011
```
La seguente query calcola l'asimmetria dei valori nella colonna col. Analogamente all'esempio precedente, la `VALUES` clausola viene utilizzata per creare una tabella in linea con quattro righe, in cui ogni riga ha una singola colonna `col` con i valori -1000, -100, 10 e 20. La `skewness()` funzione viene quindi utilizzata per calcolare l'asimmetria dei valori nella colonna. `col` Il risultato, -1.1135657469022011, rappresenta il grado e la direzione dell'asimmetria nei dati. In questo caso, il valore di asimmetria negativo indica che i dati sono inclinati verso sinistra, con la maggior parte dei valori concentrati sul lato destro della distribuzione.
```
SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);
-1.1135657469022011
```
# Funzioni STDDEV\$1SAMP e STDDEV\$1POP
Le funzioni STDDEV\$1SAMP e STDDEV\$1POP restituiscono la deviazione standard del campione e della popolazione di un insieme di valori numerici (integer, numero decimale, numero in virgola mobile). Il risultato della funzione STDDEV\$1SAMP è equivalente alla radice quadrata della varianza campione dello stesso insieme di valori.
STDDEV\$1SAMP e STDDEV sono sinonimi della stessa funzione.
## Sintassi
```
STDDEV_SAMP | STDDEV ( [ DISTINCT | ALL ] expression) STDDEV_POP ( [ DISTINCT | ALL ] expression)
```
L'espressione deve avere un tipo di dati numerico. Indipendentemente dal tipo di dati dell'espressione, il tipo di restituzione di questa funzione è un numero a precisione doppia.
**Nota**
La deviazione standard viene calcolata utilizzando l'aritmetica del numero in virgola mobile, che potrebbe causare una leggera imprecisione.
## Note per l'utilizzo
Quando la deviazione standard del campione (STDDEV o STDDEV\$1SAMP) viene calcolata per un'espressione che consiste in un singolo valore, il risultato della funzione è NULL non 0.
## Esempi
La seguente query restituisce la media dei valori nella colonna VENUESEATS della tabella VENUE, seguita dalla deviazione standard del campione e dalla deviazione standard della popolazione dello stesso insieme di valori. VENUESEATS è una colonna INTEGER. Il ridimensionamento del risultato è ridotto a 2 cifre.
```
select avg(venueseats),
cast(stddev_samp(venueseats) as dec(14,2)) stddevsamp,
cast(stddev_pop(venueseats) as dec(14,2)) stddevpop
from venue;
avg | stddevsamp | stddevpop
-------+------------+-----------
17503 | 27847.76 | 27773.20
(1 row)
```
La seguente query restituisce la deviazione standard del campione per la colonna COMMISSIONE nella tabella SALES. COMMISSION è una colonna DECIMAL. Il ridimensionamento del risultato è ridotto a 10 cifre.
```
select cast(stddev(commission) as dec(18,10))
from sales;
stddev
----------------
130.3912659086
(1 row)
```
La seguente query assegna la deviazione standard del campione per la colonna COMMISSIONE come un integer.
```
select cast(stddev(commission) as integer)
from sales;
stddev
--------
130
(1 row)
```
La seguente query restituisce sia la deviazione standard del campione sia la radice quadrata della varianza campionaria per la colonna COMMISSIONE. I risultati di questi calcoli sono gli stessi.
```
select
cast(stddev_samp(commission) as dec(18,10)) stddevsamp,
cast(sqrt(var_samp(commission)) as dec(18,10)) sqrtvarsamp
from sales;
stddevsamp | sqrtvarsamp
----------------+----------------
130.3912659086 | 130.3912659086
(1 row)
```
# SUMe funzioni SUM DISTINCT
La SUM funzione restituisce la somma dei valori della colonna di input o dell'espressione. La SUM funzione funziona con valori numerici e ignora i valori. NULL
La SUM DISTINCT funzione elimina tutti i valori duplicati dall'espressione specificata prima di calcolare la somma.
## Sintassi
```
SUM (DISTINCT column )
```
## Arguments (Argomenti)
*column*
La colonna di destinazione su cui opera la funzione. La colonna contiene qualsiasi tipo di dato numerico.
## Esempi
Trova la somma di tutte le commissioni pagate dalla SALES tabella.
```
select sum(commission) from sales
```
Trova la somma di tutte le commissioni distinte pagate dalla SALES tabella.
```
select sum (distinct (commission)) from sales
```
# Funzioni VAR\$1SAMP e VAR\$1POP
Le funzioni VAR\$1SAMP e VAR\$1POP restituiscono la varianza del campione e della popolazione di un insieme di valori numerici (integer, numero decimale, numero in virgola mobile). Il risultato della funzione VAR\$1SAMP è equivalente alla deviazione standard del campione quadrato dello stesso insieme di valori.
VAR\$1SAMP e VARIANCE sono sinonimi della stessa funzione.
## Sintassi
```
VAR_SAMP | VARIANCE ( [ DISTINCT | ALL ] expression)
VAR_POP ( [ DISTINCT | ALL ] expression)
```
L'espressione deve avere un tipo di dati integer, numero decimale o numero in virgola mobile. Indipendentemente dal tipo di dati dell'espressione, il tipo di restituzione di questa funzione è un numero a precisione doppia.
**Nota**
I risultati di queste funzioni potrebbero variare tra i cluster di data warehouse, a seconda della configurazione del cluster in ciascun caso.
## Note per l'utilizzo
Quando la varianza del campione (VARIANCE o VAR\$1SAMP) viene calcolata per un'espressione che consiste in un singolo valore, il risultato della funzione è NULL non 0.
## Esempi
La seguente query restituisce l'esempio arrotondato e la varianza di popolazione della colonna NUMTICKETS nella tabella LISTING.
```
select avg(numtickets),
round(var_samp(numtickets)) varsamp,
round(var_pop(numtickets)) varpop
from listing;
avg | varsamp | varpop
-----+---------+--------
10 | 54 | 54
(1 row)
```
La seguente query esegue gli stessi calcoli ma assegna i risultati ai valori decimali.
```
select avg(numtickets),
cast(var_samp(numtickets) as dec(10,4)) varsamp,
cast(var_pop(numtickets) as dec(10,4)) varpop
from listing;
avg | varsamp | varpop
-----+---------+---------
10 | 53.6291 | 53.6288
(1 row)
```
# Funzioni di array
Questa sezione descrive le funzioni di array per SQL supportate in. AWS Clean Rooms
**Topics**
+ [Funzione ARRAY](array.md)
+ [Funzione ARRAY\$1CONTAINS](array_contains.md)
+ [Funzione ARRAY\$1DISTINCT](array_distinct.md)
+ [Funzione ARRAY\$1EXCEPT](array_except.md)
+ [Funzione ARRAY\$1INTERSECT](array_intersect.md)
+ [Funzione ARRAY\$1JOIN](array_join.md)
+ [Funzione ARRAY\$1REMOVE](array_remove.md)
+ [Funzione ARRAY\$1UNION](array_union.md)
+ [Funzione EXPLODE](explode.md)
+ [Funzione FLATTEN](flatten.md)
# Funzione ARRAY
Crea un array con gli elementi dati.
## Sintassi
```
ARRAY( [ expr1 ] [ , expr2 [ , ... ] ] )
```
## Argomento
*expr1, expr2*
Espressioni di qualsiasi tipo di dati ad eccezione dei tipi di data e ora. Non è necessario che gli argomenti siano dello stesso tipo di dati.
## Tipo restituito
La funzione array restituisce un ARRAY con gli elementi dell'espressione.
## Esempio
L'esempio seguente mostra una matrice di valori numerici e una matrice di diversi tipi di dati.
```
--an array of numeric values
select array(1,50,null,100);
array
------------------
[1,50,null,100]
(1 row)
--an array of different data types
select array(1,'abc',true,3.14);
array
-----------------------
[1,"abc",true,3.14]
(1 row)
```
# Funzione ARRAY\$1CONTAINS
La funzione ARRAY\$1CONTAINS può essere utilizzata per eseguire controlli di appartenenza di base sulle strutture di dati degli array. La funzione ARRAY\$1CONTAINS è utile quando è necessario verificare se un valore specifico è presente all'interno di un array.
## Sintassi
```
array_contains(array, value)
```
## Argomenti
*matrice*
Un ARRAY da cercare.
*value*
Un'espressione con un tipo che condivide un tipo meno comune con gli elementi dell'array.
## Tipo restituito
La funzione ARRAY\$1CONTAINS restituisce un valore BOOLEAN.
Se il valore è NULL, il risultato è NULL.
Se un elemento dell'array è NULL, il risultato è NULL se il valore non corrisponde a nessun altro elemento.
## Esempi
L'esempio seguente verifica se l'array `[1, 2, 3]` contiene il valore. `4` Poiché l'array`[1, 2, 3`] non contiene il valore`4`, viene restituita la funzione array\$1contains. `false`
```
SELECT array_contains(array(1, 2, 3), 4)
false
```
L'esempio seguente verifica se l'array `[1, 2, 3]` contiene il valore. `2` Poiché l'array `[1, 2, 3]` contiene il valore`2`, viene restituita la funzione array\$1contains. `true`
```
SELECT array_contains(array(1, 2, 3), 2);
true
```
# Funzione ARRAY\$1DISTINCT
La funzione ARRAY\$1DISTINCT può essere utilizzata per rimuovere valori duplicati da un array. La funzione ARRAY\$1DISTINCT è utile quando è necessario rimuovere i duplicati da un array e lavorare solo con gli elementi unici. Ciò può essere utile in scenari in cui si desidera eseguire operazioni o analisi su un set di dati senza l'interferenza di valori ripetuti.
## Sintassi
```
array_distinct(array)
```
## Argomenti
*matrice*
Un'espressione ARRAY.
## Tipo restituito
La funzione ARRAY\$1DISTINCT restituisce un ARRAY che contiene solo gli elementi unici dell'array di input.
## Esempi
In questo esempio, l'array di input `[1, 2, 3, null, 3]` contiene un valore duplicato di. `3` La `array_distinct` funzione rimuove questo valore duplicato `3` e restituisce un nuovo array con gli elementi unici:. `[1, 2, 3, null]`
```
SELECT array_distinct(array(1, 2, 3, null, 3));
[1,2,3,null]
```
In questo esempio, la matrice di input `[1, 2, 2, 3, 3, 3]` contiene valori duplicati di `2` e. `3` La `array_distinct` funzione rimuove questi duplicati e restituisce un nuovo array con gli elementi unici:. `[1, 2, 3]`
```
SELECT array_distinct(array(1, 2, 2, 3, 3, 3))
[1,2,3]
```
# Funzione ARRAY\$1EXCEPT
La funzione ARRAY\$1EXCEPT accetta due array come argomenti e restituisce un nuovo array che contiene solo gli elementi presenti nel primo array ma non nel secondo array.
ARRAY\$1EXCEPT è utile quando è necessario trovare gli elementi che sono unici per un array rispetto a un altro. Questo può essere utile in scenari in cui è necessario eseguire operazioni simili a set sugli array, come trovare la differenza tra due set di dati.
## Sintassi
```
array_except(array1, array2)
```
## Argomenti
*matrice 1*
Un ARRAY di qualsiasi tipo con elementi comparabili.
*matrice 2*
*Un ARRAY di elementi che condividono un tipo meno comune con gli elementi di array1.*
## Tipo restituito
*La funzione ARRAY\$1EXCEPT restituisce un ARRAY di tipo corrispondente a array1 senza duplicati.*
## Esempi
In questo esempio, il primo array `[1, 2, 3]` contiene gli elementi 1, 2 e 3. Il secondo array `[2, 3, 4]` contiene gli elementi 2, 3 e 4. La `array_except` funzione rimuove gli elementi 2 e 3 dal primo array, poiché sono presenti anche nel secondo array. L'output risultante è l'array`[1]`.
```
SELECT array_except(array(1, 2, 3), array(2, 3, 4))
[1]
```
In questo esempio, il primo array `[1, 2, 3]` contiene gli elementi 1, 2 e 3. Il secondo array `[1, 3, 5]` contiene gli elementi 1, 3 e 5. La `array_except` funzione rimuove gli elementi 1 e 3 dal primo array, poiché sono presenti anche nel secondo array. L'output risultante è l'array`[2]`.
```
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
[2]
```
# Funzione ARRAY\$1INTERSECT
La funzione ARRAY\$1INTERSECT accetta due array come argomenti e restituisce un nuovo array che contiene gli elementi presenti in entrambi gli array di input. Questa funzione è utile quando è necessario trovare gli elementi comuni tra due array. Ciò può essere utile in scenari in cui è necessario eseguire operazioni simili a set sugli array, ad esempio trovare l'intersezione tra due set di dati.
## Sintassi
```
array_intersect(array1, array2)
```
## Argomenti
*matrice 1*
Un ARRAY di qualsiasi tipo con elementi comparabili.
*matrice 2*
Un ARRAY di elementi che condividono un tipo meno comune con gli elementi di array1.
## Tipo restituito
La funzione ARRAY\$1INTERSECT restituisce un ARRAY di tipo corrispondente a array1 senza duplicati ed elementi contenuti sia in array1 che in array2.
## Esempi
In questo esempio, il primo array contiene gli elementi 1, 2 e 3. `[1, 2, 3]` Il secondo array `[1, 3, 5]` contiene gli elementi 1, 3 e 5. La funzione ARRAY\$1INTERSECT identifica gli elementi comuni tra i due array, che sono 1 e 3. L'array `[1, 3]` di output risultante è.
```
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
[1,3]
```
# Funzione ARRAY\$1JOIN
La funzione ARRAY\$1JOIN accetta due argomenti: il primo argomento è l'array di input che verrà unito. Il secondo argomento è la stringa separatrice che verrà utilizzata per concatenare gli elementi dell'array. Questa funzione è utile quando è necessario convertire una matrice di stringhe (o qualsiasi altro tipo di dati) in un'unica stringa concatenata. Ciò può essere utile negli scenari in cui si desidera presentare una matrice di valori come una singola stringa formattata, ad esempio per scopi di visualizzazione o per l'utilizzo in ulteriori elaborazioni.
## Sintassi
```
array_join(array, delimiter[, nullReplacement])
```
## Argomenti
*matrice*
Qualsiasi tipo di ARRAY, ma i relativi elementi vengono interpretati come stringhe.
*delimiter*
Una STRINGA utilizzata per separare gli elementi dell'array concatenati.
*Sostituzione nulla*
Una STRINGA usata per esprimere un valore NULL nel risultato.
## Tipo restituito
La funzione ARRAY\$1JOIN restituisce una STRING in cui gli elementi dell'array sono separati da un delimitatore e vengono sostituiti gli elementi nulli. `nullReplacement` Se `nullReplacement` viene omesso, gli elementi vengono filtrati. `null` Se un argomento è`NULL`, il risultato è. `NULL`
## Esempi
In questo esempio, la funzione ARRAY\$1JOIN prende l'array `['hello', 'world']` e unisce gli elementi utilizzando il separatore `' '` (un carattere di spazio). L'output risultante è la stringa. `'hello world'`
```
SELECT array_join(array('hello', 'world'), ' ');
hello world
```
In questo esempio, la funzione ARRAY\$1JOIN prende l'array `['hello', null, 'world']` e unisce gli elementi utilizzando il separatore `' '` (un carattere di spazio). Il `null` valore viene sostituito con la stringa `','` sostitutiva fornita (una virgola). L'output risultante è la stringa`'hello , world'`.
```
SELECT array_join(array('hello', null ,'world'), ' ', ',');
hello , world
```
# Funzione ARRAY\$1REMOVE
La funzione ARRAY\$1REMOVE accetta due argomenti: il primo argomento è l'array di input da cui verranno rimossi gli elementi. Il secondo argomento è il valore che verrà rimosso dall'array. Questa funzione è utile quando è necessario rimuovere elementi specifici da un array. Ciò può essere utile in scenari in cui è necessario eseguire la pulizia o la preelaborazione dei dati su una matrice di valori.
## Sintassi
```
array_remove(array, element)
```
## Argomenti
*matrice*
Un ARRAY.
*elemento*
Un'espressione di un tipo che condivide un tipo meno comune con gli elementi dell'array.
## Tipo restituito
La funzione ARRAY\$1REMOVE restituisce il tipo di risultato corrispondente al tipo dell'array. Se l'elemento da rimuovere è`NULL`, il risultato è. `NULL`
## Esempi
In questo esempio, la funzione ARRAY\$1REMOVE prende l'array `[1, 2, 3, null, 3]` e rimuove tutte le occorrenze del valore 3. L'output risultante è l'array. `[1, 2, null]`
```
SELECT array_remove(array(1, 2, 3, null, 3), 3);
[1,2,null]
```
# Funzione ARRAY\$1UNION
La funzione ARRAY\$1UNION accetta due array come argomenti e restituisce un nuovo array che contiene gli elementi unici di entrambi gli array di input. Questa funzione è utile quando è necessario combinare due array ed eliminare eventuali elementi duplicati. Ciò può essere utile in scenari in cui è necessario eseguire operazioni simili a set sugli array, ad esempio trovare l'unione tra due set di dati.
## Sintassi
```
array_union(array1, array2)
```
## Argomenti
*matrice 1*
Un ARRAY.
*matrice 2*
*Un ARRAY dello stesso tipo di array1.*
## Tipo restituito
La funzione ARRAY\$1UNION restituisce un ARRAY dello stesso tipo di array.
## Esempio
In questo esempio, il primo array `[1, 2, 3]` contiene gli elementi 1, 2 e 3. Il secondo array `[1, 3, 5]` contiene gli elementi 1, 3 e 5. La funzione ARRAY\$1UNION combina gli elementi unici di entrambi gli array, dando origine all'array di output. `[1, 2, 3, 5]` T
```
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
[1,2,3,5]
```
# Funzione EXPLODE
La funzione EXPLODE viene utilizzata per trasformare una singola riga con una matrice o una colonna di mappa in più righe, in cui ogni riga corrisponde a un singolo elemento dell'array o della mappa.
## Sintassi
```
explode(expr)
```
## Argomenti
*expr*
Un'espressione di matrice o un'espressione cartografica.
## Tipo restituito
La funzione EXPLODE restituisce un set di righe, in cui ogni riga rappresenta un singolo elemento della matrice o della mappa di input.
Il tipo di dati delle righe di output dipende dal tipo di dati degli elementi nella matrice o nella mappa di input.
## Esempi
L'esempio seguente prende l'array a riga singola [10, 20] e lo trasforma in due righe separate, ciascuna contenente uno degli elementi dell'array (10 e 20).
```
SELECT explode(array(10, 20));
```
Nel primo esempio, l'array di input è stato passato direttamente come argomento a. `explode()` In questo esempio, l'array di input viene specificato utilizzando la `=>` sintassi, in cui viene fornito esplicitamente il nome della colonna (`collection`).
```
SELECT explode(array(10, 20));
```
Entrambi gli approcci sono validi e consentono di ottenere lo stesso risultato, ma la seconda sintassi può essere più utile quando è necessario esplodere una colonna da un set di dati più grande, anziché un semplice array letterale.
# Funzione FLATTEN
La funzione FLATTEN viene utilizzata per «appiattire» una struttura a matrice annidata in una singola matrice piatta.
## Sintassi
```
flatten(arrayOfArrays)
```
## Argomenti
*arrayOfArrays*
Una serie di array.
## Tipo restituito
La funzione FLATTEN restituisce un array.
## Esempio
In questo esempio, l'input è un array annidato con due array interni e l'output è un singolo array flat contenente tutti gli elementi degli array interni. La funzione FLATTEN prende l'array annidato `[[1, 2], [3, 4]]` e combina tutti gli elementi in un unico array. `[1, 2, 3, 4]`
```
SELECT flatten(array(array(1, 2), array(3, 4)));
[1,2,3,4]
```
# Espressioni condizionali
In SQL, le espressioni condizionali vengono utilizzate per prendere decisioni in base a determinate condizioni. Consentono di controllare il flusso delle istruzioni SQL e restituire valori diversi o eseguire azioni diverse in base alla valutazione di una o più condizioni.
AWS Clean Rooms supporta le seguenti espressioni condizionali:
**Topics**
+ [Espressione condizionale CASE](CASE_function.md)
+ [COALESCEespressione](coalesce-function.md)
+ [espressione MASSIMA e MINIMA](GREATEST_LEAST.md)
+ [Espressione IF](IF.md)
+ [espressione IS\$1NULL](IS_NULL.md)
+ [espressione IS\$1NOT\$1NULL](IS_NOT_NULL.md)
+ [Funzioni NVL e COALESCE](NVL_function.md)
+ [NVL2 funzione](NVL2.md)
+ [Funzione NULLIF](NULLIF_function.md)
# Espressione condizionale CASE
L'espressione CASE è un'espressione condizionale, simile alle if/then/else istruzioni presenti in altre lingue. CASE è utilizzata per specificare un risultato quando ci sono condizioni multiple. Usa CASE quando un'espressione SQL è valida, ad esempio in un comando SELECT.
Esistono due tipi di espressioni CASE: semplici e ricercate.
+ Nelle espressioni CASE semplici, un'espressione viene confrontata con un valore. Quando viene trovata una corrispondenza, viene applicata l'azione specificata nella clausola THEN. Se non viene trovata una corrispondenza, viene applicata l'azione nella clausola ELSE.
+ Nelle espressioni CASE cercate, ogni CASE viene valutata in base a un'espressione booleana e l'istruzione CASE restituisce la prima CASE corrispondente. Se non vengono trovate corrispondenze tra le clausole WHEN, viene restituita l'operazione nella clausola ELSE.
## Sintassi
Semplice istruzione CASE usata per abbinare le condizioni:
```
CASE expression
WHEN value THEN result
[WHEN...]
[ELSE result]
END
```
Istruzione CASE ricercata usata per valutare ogni condizione:
```
CASE
WHEN condition THEN result
[WHEN ...]
[ELSE result]
END
```
## Argomenti
*espressione*
Un nome di colonna o qualsiasi espressione valida.
*value*
Valore con cui viene confrontata l'espressione, ad esempio una costante numerica o una stringa di caratteri.
*result*
Il valore o espressione di destinazione che viene restituito quando viene valutata un'espressione o una condizione booleana. I tipi di dati di tutte le espressioni dei risultati devono essere convertibili in un singolo tipo di output.
*condizione*
Un'espressione booleana che restituisce true o false. Se la *condizione* è true, il valore dell'espressione CASE è il risultato che segue la condizione e il resto dell'espressione CASE non viene elaborato. Se la *condizione* è false, vengono valutate tutte le clausole WHEN successive. Se nessun risultato della condizione WHEN è true, il valore dell'espressione CASE è il risultato della clausola ELSE. Se la clausola ELSE viene omessa e nessuna condizione è true, il risultato è null.
## Esempi
Utilizzare una semplice espressione CASE per sostituire `New York City` con `Big Apple` in una query sulla tabella VENUE. Sostituire tutti gli altri nomi di città con `other`.
```
select venuecity,
case venuecity
when 'New York City'
then 'Big Apple' else 'other'
end
from venue
order by venueid desc;
venuecity | case
-----------------+-----------
Los Angeles | other
New York City | Big Apple
San Francisco | other
Baltimore | other
...
```
Utilizzare un'espressione CASE ricercata per assegnare numeri di gruppo in base al valore PRICEPAID per le vendite di biglietti singoli:
```
select pricepaid,
case when pricepaid <10000 then 'group 1'
when pricepaid >10000 then 'group 2'
else 'group 3'
end
from sales
order by 1 desc;
pricepaid | case
----------+---------
12624 | group 2
10000 | group 3
10000 | group 3
9996 | group 1
9988 | group 1
...
```
# COALESCEespressione
Un'COALESCEespressione restituisce il valore della prima espressione dell'elenco che non è nulla. Se tutte le espressioni sono null, il risultato è null. Quando viene trovato un valore non null, le espressioni rimanenti nell'elenco non vengono valutate.
Questo tipo di espressione è utile quando si desidera restituire un valore di backup per qualcosa quando il valore preferito è mancante o null. Ad esempio, una query può restituire uno dei tre numeri di telefono (cellulare, casa o lavoro, in tale ordine), a seconda di quale si trova prima nella tabella (non null).
## Sintassi
```
COALESCE (expression, expression, ... )
```
## Esempi
Applica COALESCE l'espressione a due colonne.
```
select coalesce(start_date, end_date)
from datetable
order by 1;
```
Il nome di colonna predefinito per un'espressione NVL è. COALESCE La seguente query restituisce gli stessi risultati.
```
select coalesce(start_date, end_date) from datetable order by 1;
```
# espressione MASSIMA e MINIMA
Restituisce il valore più grande o più piccolo da un elenco numeri di espressioni.
## Sintassi
```
GREATEST (value [, ...])
LEAST (value [, ...])
```
## Parametri
*expression\$1list*
Un elenco di espressioni separate da virgole, come ad esempio i nomi di colonne. Le espressioni devono essere tutte convertibili in un tipo di dati comune. I valori NULL nell'elenco vengono ignorati. Se tutte le espressioni vengono valutate su NULL, il risultato è NULL.
## Valori restituiti
Restituisce il valore massimo (per GREATEST) o minimo (per LEAST) dell'elenco di espressioni fornito.
## Esempio
Nell'esempio seguente viene restituito il valore più alto in ordine alfabetico per `firstname` oppure `lastname`.
```
select firstname, lastname, greatest(firstname,lastname) from users
where userid < 10
order by 3;
firstname | lastname | greatest
-----------+-----------+-----------
Alejandro | Rosalez | Ratliff
Carlos | Salazar | Carlos
Jane | Doe | Doe
John | Doe | Doe
John | Stiles | John
Shirley | Rodriguez | Rodriguez
Terry | Whitlock | Terry
Richard | Roe | Richard
Xiulan | Wang | Wang
(9 rows)
```
# Espressione IF
La funzione condizionale IF restituisce uno dei due valori in base a una condizione.
Questa funzione è un'istruzione di flusso di controllo comune utilizzata in SQL per prendere decisioni e restituire valori diversi in base alla valutazione di una condizione. È utile per implementare una semplice logica if-else all'interno di una query.
## Sintassi
```
if(expr1, expr2, expr3)
```
## Argomenti
*espr (1)*
La condizione o l'espressione che viene valutata. In caso affermativo`true`, la funzione restituirà il valore di *expr2*. *Se *expr1* è`false`, la funzione restituirà il valore di expr3.*
*espr (2)*
*L'espressione che viene valutata e restituita se expr1 è.* `true`
*expr 3*
*L'espressione che viene valutata e restituita se expr1 è.* `false`
## Valori restituiti
Se `expr1` restituisce a`true`, restituisce; in caso contrario restituisce`expr2`. `expr3`
## Esempio
L'esempio seguente utilizza la `if()` funzione per restituire uno dei due valori in base a una condizione. La condizione da valutare è`1 < 2`, ovvero`true`, quindi `'a'` viene restituito il primo valore.
```
SELECT if(1 < 2, 'a', 'b');
a]
```
# espressione IS\$1NULL
L'espressione IS\$1NULL condizionale viene utilizzata per verificare se un valore è nullo.
Questa espressione è sinonimo di. IS NULL
## Sintassi
```
is_null(expr)
```
## Argomenti
*expr*
Un'espressione di qualsiasi tipo.
## Valori restituiti
L'espressione IS\$1NULL condizionale restituisce un valore booleano. Se `expr1` è NULL, restituisce, altrimenti restituisce`true`. `false`
## Esempi
L'esempio seguente verifica se il valore `1` è null e restituisce il risultato booleano `true` perché 1 è un valore valido e non nullo.
```
SELECT is not null(1);
true
```
L'esempio seguente seleziona la `id` colonna dalla `squirrels` tabella, ma solo per le righe in cui si trova la colonna dell'età. `null`
```
SELECT id FROM squirrels WHERE is_null(age)
```
# espressione IS\$1NOT\$1NULL
L'espressione IS\$1NOT\$1NULL condizionale viene utilizzata per verificare se un valore non è nullo.
Questa espressione è sinonimo di. IS NOT NULL
## Sintassi
```
is_not_null(expr)
```
## Argomenti
*expr*
Un'espressione di qualsiasi tipo.
## Valori restituiti
L'espressione IS\$1NOT\$1NULL condizionale restituisce un valore booleano. Se non `expr1` è NULL, restituisce, altrimenti restituisce`true`. `false`
## Esempi
L'esempio seguente verifica se il valore non `1` è nullo e restituisce il risultato booleano `true` perché 1 è un valore valido e non nullo.
```
SELECT is not null(1);
true
```
L'esempio seguente seleziona la `id` colonna dalla `squirrels` tabella, ma solo per le righe in cui non è presente la colonna dell'età. `null`
```
SELECT id FROM squirrels WHERE is_not_null(age)
```
# Funzioni NVL e COALESCE
Restituisce il valore della prima espressione che non è null in una serie di espressioni. Quando viene trovato un valore non null, le restanti espressioni nell'elenco non vengono valutate.
NVL è identica a COALESCE. Sono sinonimi. Questo argomento illustra la sintassi e contiene esempi per entrambe.
## Sintassi
```
NVL( expression, expression, ... )
```
La sintassi di COALESCE è la stessa:
```
COALESCE( expression, expression, ... )
```
Se tutte le espressioni sono null, il risultato è null.
Queste funzioni sono utili quando si desidera restituire un valore secondario quando manca un valore primario o è null. Ad esempio, una query potrebbe restituire il primo dei tre numeri di telefono disponibili: cellulare, casa o ufficio. L'ordine delle espressioni nella funzione determina l'ordine di valutazione.
## Argomenti
*espressione*
Un'espressione, come ad esempio un nome di colonna, da valutare per lo stato null.
## Tipo restituito
AWS Clean Rooms determina il tipo di dati del valore restituito in base alle espressioni di input. Se i tipi di dati delle espressioni di input non hanno un tipo comune, viene restituito un errore.
## Esempi
Se l'elenco contiene espressioni intere, la funzione restituisce un numero intero.
```
SELECT COALESCE(NULL, 12, NULL);
coalesce
--------------
12
```
Questo esempio, che è uguale all'esempio precedente tranne per il fatto che utilizza NVL, restituisce lo stesso risultato.
```
SELECT NVL(NULL, 12, NULL);
coalesce
--------------
12
```
Nell'esempio seguente viene restituito un tipo di stringa.
```
SELECT COALESCE(NULL, 'AWS Clean Rooms', NULL);
coalesce
--------------
AWS Clean Rooms
```
L'esempio seguente genera un errore perché i tipi di dati variano nell'elenco delle espressioni. In questo caso, nell'elenco sono presenti sia un tipo di stringa che un tipo numerico.
```
SELECT COALESCE(NULL, 'AWS Clean Rooms', 12);
ERROR: invalid input syntax for integer: "AWS Clean Rooms"
```
# NVL2 funzione
Restituisce uno dei due valori in base al fatto che un'espressione specificata valuti in NULL o NOT NULL.
## Sintassi
```
NVL2 ( expression, not_null_return_value, null_return_value )
```
## Argomenti
*espressione*
Un'espressione, come ad esempio un nome di colonna, da valutare per lo stato null.
*not\$1null\$1return\$1value*
Il valore restituito se l' *espressione* valuta in NOT NULL. Il valore *not\$1null\$1return\$1value* deve avere lo stesso tipo di dati dell' *espressione* o essere implicitamente convertibile in quel tipo di dati.
*null\$1return\$1value*
Il valore restituito se l' *espressione* valuta in NULL. Il valore *null\$1return\$1value* deve avere lo stesso tipo di dati dell' *espressione* o essere implicitamente convertibile in quel tipo di dati.
## Tipo restituito
Il tipo di NVL2 restituzione è determinato come segue:
+ Se *not\$1null\$1return\$1value* o *null\$1return\$1value* è null, viene restituito il tipo di dati dell'espressione not null.
Se sia *not\$1null\$1return\$1value* sia *null\$1return\$1value* sono non null:
+ Se sia *not\$1null\$1return\$1value* sia *null\$1return\$1value* hanno lo stesso tipo di dati, viene restituito quel tipo di dati.
+ Se *not\$1null\$1return\$1value* e *null\$1return\$1value* hanno tipi di dati numerici diversi, viene restituito il tipo di dati numerico compatibile più piccolo.
+ Se *not\$1null\$1return\$1value* e *null\$1return\$1value* hanno tipi di dati di datetime diversi, viene restituito un tipo di dati numerici di timestamp.
+ Se *not\$1null\$1return\$1value* e *null\$1return\$1value* hanno diversi tipi di dati di carattere, viene restituito il tipo di dati di *not\$1null\$1return\$1value*.
+ Se *not\$1null\$1return\$1value* e *null\$1return\$1value* hanno tipi di dati numerici e non numerici misti viene restituito il tipo di dati di *not\$1null\$1return\$1value*.
**Importante**
Negli ultimi due casi in cui viene restituito il tipo di dati di *not\$1null\$1return\$1value*, *null\$1return\$1value* viene assegnato implicitamente a quel tipo di dati. Se i tipi di dati non sono compatibili, la funzione ha esito negativo.
## Note per l'utilizzo
*Infatti NVL2, il valore restituito avrà il valore del parametro *not\$1null\$1return\$1value o null\$1return\$1value*, a seconda di quale sia selezionato dalla funzione, ma avrà il tipo di dati *not\$1null\$1return\$1value*.*
Ad esempio, supponendo che la colonna 1 sia NULL, le seguenti query restituiranno lo stesso valore. Tuttavia, il tipo di dati del valore restituito NVL2 DECODE sarà INTEGER e il tipo di dati del valore restituito sarà VARCHAR.
```
select decode(column1, null, 1234, '2345');
select nvl2(column1, '2345', 1234);
```
## Esempio
L'esempio seguente modifica alcuni dati di esempio, quindi valuta due campi per fornire informazioni di contatto appropriate per gli utenti:
```
update users set email = null where firstname = 'Aphrodite' and lastname = 'Acevedo';
select (firstname + ' ' + lastname) as name,
nvl2(email, email, phone) AS contact_info
from users
where state = 'WA'
and lastname like 'A%'
order by lastname, firstname;
name contact_info
--------------------+-------------------------------------------
Aphrodite Acevedo (555) 555-0100
Caldwell Acevedo Nunc.sollicitudin@example.ca
Quinn Adams vel@example.com
Kamal Aguilar quis@example.com
Samson Alexander hendrerit.neque@example.com
Hall Alford ac.mattis@example.com
Lane Allen et.netus@example.com
Xander Allison ac.facilisis.facilisis@example.com
Amaya Alvarado dui.nec.tempus@example.com
Vera Alvarez at.arcu.Vestibulum@example.com
Yetta Anthony enim.sit@example.com
Violet Arnold ad.litora@example.comm
August Ashley consectetuer.euismod@example.com
Karyn Austin ipsum.primis.in@example.com
Lucas Ayers at@example.com
```
# Funzione NULLIF
Confronta due argomenti e restituisce null se gli argomenti sono uguali. Se non sono uguali, viene restituito il primo argomento.
## Sintassi
L'espressione NULLIF confronta due argomenti e restituisce null se gli argomenti sono uguali. Se non sono uguali, viene restituito il primo argomento. Questa espressione è l'inverso dell'espressione NVL o COALESCE.
```
NULLIF ( expression1, expression2 )
```
## Argomenti
*expression1, expression2*
Le colonne o le espressioni di destinazione che vengono confrontate. Il tipo di restituzione è uguale al tipo della prima espressione.
## Esempi
Nell'esempio seguente, la query restituisce la stringa `first` perché gli argomenti non sono uguali.
```
SELECT NULLIF('first', 'second');
case
-------
first
```
Nell'esempio seguente, la query restituisce `NULL` perché gli argomenti della stringa letterale non sono uguali.
```
SELECT NULLIF('first', 'first');
case
-------
NULL
```
Nell'esempio seguente, la query restituisce `1` perché gli argomenti del numero intero non sono uguali.
```
SELECT NULLIF(1, 2);
case
-------
1
```
Nell'esempio seguente, la query restituisce `NULL` perché gli argomenti del numero intero sono uguali.
```
SELECT NULLIF(1, 1);
case
-------
NULL
```
Nell'esempio seguente, la query restituisce null quando i valori LISTID e SALESID corrispondono:
```
select nullif(listid,salesid), salesid
from sales where salesid<10 order by 1, 2 desc;
listid | salesid
--------+---------
4 | 2
5 | 4
5 | 3
6 | 5
10 | 9
10 | 8
10 | 7
10 | 6
| 1
(9 rows)
```
# Funzioni costruttore
Una funzione di costruzione SQL è una funzione utilizzata per creare nuove strutture di dati, come matrici o mappe.
Prendono alcuni valori di input e restituiscono un nuovo oggetto della struttura dati. Le funzioni di costruzione in genere prendono il nome dal tipo di dati che creano, ad esempio ARRAY o MAP.
Le funzioni di costruzione sono diverse dalle funzioni scalari o dalle funzioni aggregate, che operano su dati esistenti e restituiscono un singolo valore. Le funzioni di costruzione vengono utilizzate per creare nuove strutture di dati che possono quindi essere utilizzate per ulteriori elaborazioni o analisi dei dati.
AWS Clean Rooms supporta le seguenti funzioni di costruzione:
**Topics**
+ [funzione di costruzione MAP](map_function.md)
+ [funzione di costruzione NAMED\$1STRUCT](named-struct_function.md)
+ [funzione di costruzione STRUCT](struct_function.md)
# funzione di costruzione MAP
La funzione di costruzione MAP crea una mappa con le coppie chiave/valore specificate.
Le funzioni di costruzione come MAP sono utili quando è necessario creare nuove strutture di dati a livello di codice all'interno delle query SQL. Consentono di creare strutture di dati complesse che possono essere utilizzate per ulteriori elaborazioni o analisi dei dati.
## Sintassi
```
map(key0, value0, key1, value1, ...)
```
## Argomenti
*chiave 0*
Un'espressione di qualsiasi tipo comparabile. Tutte le *key0* devono condividere un tipo meno comune.
*valore 0*
Un'espressione di qualsiasi tipo. Tutti i *ValueN* devono condividere un tipo meno comune.
## Valori restituiti
*La funzione MAP restituisce un MAP con tasti digitati come tipo meno comune di *key0* e valori digitati come tipo meno comune di value0.*
## Esempi
L'esempio seguente crea una nuova mappa con due coppie chiave-valore: La chiave è associata al valore. `1.0` `'2'` La chiave `3.0` è associata al valore. `'4'` La mappa risultante viene quindi restituita come output dell'istruzione SQL.
```
SELECT map(1.0, '2', 3.0, '4');
{1.0:"2",3.0:"4"}
```
# funzione di costruzione NAMED\$1STRUCT
La funzione di costruzione NAMED\$1STRUCT crea una struttura con i nomi e i valori dei campi specificati.
Le funzioni di costruzione come NAMED\$1STRUCT sono utili quando è necessario creare nuove strutture di dati a livello di codice all'interno delle query SQL. Consentono di creare strutture di dati complesse, come strutture o record, che possono essere utilizzate per ulteriori elaborazioni o analisi dei dati.
## Sintassi
```
named_struct(name1, val1, name2, val2, ...)
```
## Argomenti
*nome1*
Un campo di denominazione letterale STRING 1.
*val1*
Un'espressione di qualsiasi tipo che specifica il valore per il campo 1.
## Valori restituiti
*La funzione NAMED\$1STRUCT restituisce una struttura con il campo 1 corrispondente al tipo di val1.*
## Esempi
L'esempio seguente crea una nuova struttura con tre campi denominati: Al campo `"a"` viene assegnato il valore. `1` Al campo `"b"` viene assegnato il valore `2.` Al campo `"c"` viene assegnato il valore`3`. La struttura risultante viene quindi restituita come output dell'istruzione SQL.
```
SELECT named_struct("a", 1, "b", 2, "c", 3);
{"a":1,"b":2,"c":3}
```
# funzione di costruzione STRUCT
La funzione di costruzione STRUCT crea una struttura con i valori di campo specificati.
Le funzioni di costruzione come STRUCT sono utili quando è necessario creare nuove strutture di dati a livello di codice all'interno delle query SQL. Consentono di creare strutture di dati complesse, come strutture o record, che possono essere utilizzate per ulteriori elaborazioni o analisi dei dati.
## Sintassi
```
struct(col1, col2, col3, ...)
```
## Argomenti
*col1*
Un nome di colonna o qualsiasi espressione valida.
## Valori restituiti
*La funzione STRUCT restituisce una struttura con *field1* corrispondente al tipo di expr1.*
Se gli argomenti sono denominati riferimenti, i nomi vengono utilizzati per denominare il campo. Altrimenti, i campi sono *denominati colN*, dove N è la posizione del campo nella struttura.
## Esempi
L'esempio seguente crea una nuova struttura con tre campi: Al primo campo viene assegnato il valore 1. Al secondo campo viene assegnato il valore 2. Al terzo campo viene assegnato il valore 3. Per impostazione predefinita, i campi nella struttura risultante sono `col1` denominati e `col3` in base alla loro posizione nell'elenco degli argomenti. `col2` La struttura risultante viene quindi restituita come output dell'istruzione SQL.
```
SELECT struct(1, 2, 3);
{"col1":1,"col2":2,"col3":3}
```
# Funzioni di formattazione del tipo di dati
Utilizzando una funzione di formattazione dei tipi di dati, è possibile convertire i valori da un tipo di dati a un altro. Per ognuna di queste funzioni, il primo argomento è sempre il valore da formattare e il secondo argomento contiene il modello per il nuovo formato.
AWS Clean Rooms Spark SQL supporta diverse funzioni di formattazione dei tipi di dati.
**Topics**
+ [BASE64 funzione](base64.md)
+ [Funzione CAST](CAST_function.md)
+ [Funzione DECODE](DECODE.md)
+ [Funzione ENCODE](ENCODE.md)
+ [Funzione HEX](HEX.md)
+ [Funzione STR\$1TO\$1MAP](STR_TO_MAP.md)
+ [TO\$1CHAR](TO_CHAR.md)
+ [Funzione TO\$1DATE](TO_DATE_function.md)
+ [TO\$1NUMBER](TO_NUMBER.md)
+ [UNBASE64 funzione](unbase64.md)
+ [Funzione UNHEX](UNHEX.md)
+ [Stringhe di formato datetime](FORMAT_strings.md)
+ [Stringhe di formato numerico](Numeric_formating.md)
# BASE64 funzione
La BASE64 funzione converte un'espressione in una stringa base 64 utilizzando la [codifica di trasferimento RFC2045 Base64](https://datatracker.ietf.org/doc/html/rfc2045) per MIME.
## Sintassi
```
base64(expr)
```
## Arguments (Argomenti)
*expr*
Un'espressione BINARY o una STRINGA che la funzione interpreterà come BINARY.
## Tipo restituito
`STRING`
## Esempio
Per convertire l'input di stringa specificato nella sua rappresentazione codificata Base64. usa il seguente esempio. Il risultato è la rappresentazione codificata in Base64 della stringa di input 'Spark SQL', che è 'U3BHCMsGU1FM'.
```
SELECT base64('Spark SQL');
U3BhcmsgU1FM
```
# Funzione CAST
La funzione CAST converte un tipo di dati in un altro tipo di dati compatibile. Ad esempio, puoi convertire una stringa in una data o un tipo numerico in una stringa. CAST esegue una conversione in fase di runtime, il che significa che la conversione non modifica il tipo di dati di un valore in una tabella di origine. Viene modificato solo nel contesto della query.
Alcuni tipi di dati richiedono una conversione esplicita in altri tipi di dati utilizzando la funzione CAST. Altri tipi di dati possono essere convertiti implicitamente, come parte di un altro comando, senza utilizzare CAST. Per informazioni, consulta [Conversione e compatibilità dei tipi](s_Type_conversion.md).
## Sintassi
Utilizza i seguenti due formati di sintassi equivalenti per convertire espressioni da un tipo di dati a un altro:
```
CAST ( expression AS type )
```
## Arguments (Argomenti)
*espressione*
Un'espressione che valuta uno o più valori, ad esempio un nome di colonna o un letterale. La conversione di valori null restituisce null. L'espressione non può contenere stringhe vuote o vuote.
*tipo*
Una delle opzioni supportate[Tipi di dati](s_Supported_data_types.md), ad eccezione dei tipi di dati BINARY e BINARY VARIYING.
## Tipo restituito
CAST restituisce il tipo di dati specificato dall'argomento *tipo*.
**Nota**
AWS Clean Rooms restituisce un errore se si tenta di eseguire una conversione problematica, ad esempio una conversione DECIMAL che perde precisione, come la seguente:
```
select 123.456::decimal(2,1);
```
o una conversione INTEGER che provoca un eccesso:
```
select 12345678::smallint;
```
## Esempi
Le seguenti due query sono equivalenti. Entrambi assegnano un valore decimale a un integer:
```
select cast(pricepaid as integer)
from sales where salesid=100;
pricepaid
-----------
162
(1 row)
```
```
select pricepaid::integer
from sales where salesid=100;
pricepaid
-----------
162
(1 row)
```
La seguente query produce un risultato simile. Non richiede dati di esempio per l'esecuzione:
```
select cast(162.00 as integer) as pricepaid;
pricepaid
-----------
162
(1 row)
```
In questo esempio, i valori in una colonna timestamp vengono convertiti come date, il che comporta la rimozione dell'ora da ogni risultato:
```
select cast(saletime as date), salesid
from sales order by salesid limit 10;
saletime | salesid
-----------+---------
2008-02-18 | 1
2008-06-06 | 2
2008-06-06 | 3
2008-06-09 | 4
2008-08-31 | 5
2008-07-16 | 6
2008-06-26 | 7
2008-07-10 | 8
2008-07-22 | 9
2008-08-06 | 10
(10 rows)
```
Se non hai usato CAST come illustrato nell'esempio precedente, i risultati includono l'ora: *18-02-2008 02:36:48*.
La seguente query converte i dati di caratteri variabili in una data. Non richiede dati di esempio per l'esecuzione.
```
select cast('2008-02-18 02:36:48' as date) as mysaletime;
mysaletime
--------------------
2008-02-18
(1 row)
```
In questo esempio, il casting dei valori in una colonna di data viene eseguito come timestamps:
```
select cast(caldate as timestamp), dateid
from date order by dateid limit 10;
caldate | dateid
--------------------+--------
2008-01-01 00:00:00 | 1827
2008-01-02 00:00:00 | 1828
2008-01-03 00:00:00 | 1829
2008-01-04 00:00:00 | 1830
2008-01-05 00:00:00 | 1831
2008-01-06 00:00:00 | 1832
2008-01-07 00:00:00 | 1833
2008-01-08 00:00:00 | 1834
2008-01-09 00:00:00 | 1835
2008-01-10 00:00:00 | 1836
(10 rows)
```
In un caso come nell'esempio precedente, è possibile ottenere un ulteriore controllo sulla formattazione dell'output utilizzando. [TO\$1CHAR](TO_CHAR.md)
In questo esempio, un integer è assegnato come una stringa di caratteri:
```
select cast(2008 as char(4));
bpchar
--------
2008
```
In questo esempio, un valore DECIMAL(6,3) viene assegnato come valore DECIMAL(4,1):
```
select cast(109.652 as decimal(4,1));
numeric
---------
109.7
```
Questo esempio mostra un'espressione più complessa. La colonna PRICEPAID (una colonna DECIMAL(8,2)) nella tabella SALES viene convertita in una colonna DECIMAL(38,2) e i valori vengono moltiplicati per 100000000000000000000:
```
select salesid, pricepaid::decimal(38,2)*100000000000000000000
as value from sales where salesid<10 order by salesid;
salesid | value
---------+----------------------------
1 | 72800000000000000000000.00
2 | 7600000000000000000000.00
3 | 35000000000000000000000.00
4 | 17500000000000000000000.00
5 | 15400000000000000000000.00
6 | 39400000000000000000000.00
7 | 78800000000000000000000.00
8 | 19700000000000000000000.00
9 | 59100000000000000000000.00
(9 rows)
```
# Funzione DECODE
La funzione DECODE è la controparte della funzione ENCODE, utilizzata per convertire una stringa in un formato binario utilizzando una codifica di caratteri specifica. La funzione DECODE prende i dati binari e li riconverte in un formato di stringa leggibile utilizzando la codifica dei caratteri specificata.
Questa funzione è utile quando è necessario lavorare con dati binari archiviati in un database e presentarli in un formato leggibile dall'uomo o quando è necessario convertire dati tra diverse codifiche di caratteri.
## Sintassi
```
decode(expr, charset)
```
## Arguments (Argomenti)
*expr*
Un'espressione BINARY codificata in un set di caratteri.
*set di caratteri*
Un'espressione STRING.
Codifiche dei set di caratteri supportate (senza distinzione tra maiuscole e minuscole):`'US-ASCII'`,,, `'ISO-8859-1'``'UTF-8'`, `'UTF-16BE'` e. `'UTF-16LE'` `'UTF-16'`
## Tipo restituito
La funzione DECODE restituisce una STRING.
## Esempio
L'esempio seguente presenta una tabella chiamata `messages` con una colonna chiamata `message_text` che memorizza i dati dei messaggi in un formato binario utilizzando la codifica dei caratteri UTF-8. La funzione DECODE riconverte i dati binari in un formato di stringa leggibile. L'output di questa query è il testo leggibile del messaggio memorizzato nella tabella dei messaggi, con l'ID`123`, convertito dal formato binario in una stringa utilizzando la codifica. `'utf-8'`
```
SELECT decode(message_text, 'utf-8') AS message
FROM messages
WHERE message_id = 123;
```
# Funzione ENCODE
La funzione ENCODE viene utilizzata per convertire una stringa nella sua rappresentazione binaria utilizzando una codifica di caratteri specificata.
Questa funzione è utile quando è necessario lavorare con dati binari o quando è necessario eseguire conversioni tra diverse codifiche di caratteri. Ad esempio, è possibile utilizzare la funzione ENCODE per archiviare dati in un database che richiede la memorizzazione binaria o quando è necessario trasferire dati tra sistemi che utilizzano codifiche di caratteri diverse.
## Sintassi
```
encode(str, charset)
```
## Arguments (Argomenti)
*str*
Un'espressione STRING da codificare.
*set di caratteri*
Un'espressione STRING che specifica la codifica.
Codifiche dei set di caratteri supportate (senza distinzione tra maiuscole e minuscole):`'US-ASCII'`,,,, e`'ISO-8859-1'`. `'UTF-8'` `'UTF-16BE'` `'UTF-16LE'` `'UTF-16'`
## Tipo restituito
La funzione ENCODE restituisce un valore BINARY.
## Esempio
L'esempio seguente converte la stringa `'abc'` nella sua rappresentazione binaria utilizzando la `'utf-8'` codifica, che in questo caso restituisce la stringa originale. Questo perché la `'utf-8'` codifica è una codifica di caratteri a larghezza variabile che può rappresentare l'intero set di caratteri ASCII (che include le lettere `'a'` e`'c'`) utilizzando un solo byte per carattere. `'b'` Pertanto, la rappresentazione binaria dell'`'abc'`utilizzo `'utf-8'` è la stessa della stringa originale.
```
SELECT encode('abc', 'utf-8');
abc
```
# Funzione HEX
La funzione HEX converte un valore numerico (un intero o un numero a virgola mobile) nella rappresentazione di stringa esadecimale corrispondente.
L'esadecimale è un sistema numerico che utilizza 16 simboli distinti (0-9 e A-F) per rappresentare valori numerici. È comunemente usato nell'informatica e nella programmazione per rappresentare dati binari in un formato più compatto e leggibile dall'uomo.
## Sintassi
```
hex(expr)
```
## Arguments (Argomenti)
*expr*
Un'espressione BIGINT, BINARY o STRING.
## Tipo restituito
HEX restituisce una STRING. La funzione restituisce la rappresentazione esadecimale dell'argomento.
## Esempio
L'esempio seguente prende come input il valore intero 17 e vi applica la funzione HEX (). L'output è`11`, che è la rappresentazione esadecimale del valore di input. `17`
```
SELECT hex(17);
11
```
L'esempio seguente converte la stringa `'Spark_SQL'` nella sua rappresentazione esadecimale. L'output è`537061726B2053514C`, che è la rappresentazione esadecimale della stringa di input. `'Spark_SQL'`
```
SELECT hex('Spark_SQL');
537061726B2053514C
```
In questo esempio, la stringa 'Spark\$1SQL' viene convertita come segue:
+ 'S' -> 53
+ 'p' -> 70
+ 'a' -> 61
+ 'r' -> 72 '
+ k' -> 6B
+ '\$1' -> 20
+ 'S' -> 53
+ 'Q' -> 51
+ 'L' -> 4C
La concatenazione di questi valori esadecimali produce l'output finale ". `537061726B2053514C"`
# Funzione STR\$1TO\$1MAP
La funzione STR\$1TO\$1MAP è una funzione di conversione. string-to-map Converte una rappresentazione in formato stringa di una mappa (o dizionario) in una vera struttura di dati cartografici.
Questa funzione è utile quando è necessario lavorare con strutture di dati cartografiche in SQL, ma i dati vengono inizialmente memorizzati come stringa. Convertendo la rappresentazione della stringa in una mappa effettiva, è quindi possibile eseguire operazioni e manipolazioni sui dati della mappa.
## Sintassi
```
str_to_map(text[, pairDelim[, keyValueDelim]])
```
## Arguments (Argomenti)
*testo*
Un'espressione STRING che rappresenta la mappa.
*PairDelim*
Un valore letterale STRING opzionale che specifica come separare le voci. Il valore predefinito è una virgola (). `','`
*keyValueDelim*
Un valore letterale STRING opzionale che specifica come separare ogni coppia chiave-valore. Il valore predefinito è i due punti (). `':'`
## Tipo restituito
La funzione STR\$1TO\$1MAP restituisce una MAP di STRING sia per le chiavi che per i valori. Sia *PairDelim* che vengono trattati come espressioni regolari *keyValueDelim*.
## Esempio
L'esempio seguente prende la stringa di input e i due argomenti di delimitazione e converte la rappresentazione della stringa in una vera struttura di dati della mappa. In questo esempio specifico, la stringa di input `'a:1,b:2,c:3'` rappresenta una mappa con le seguenti coppie chiave-valore: `'a'` è la chiave e è il valore. `'1'` `'b'`è la chiave ed `'2'` è il valore. `'c'`è la chiave ed `'3'` è il valore. Il `','` delimitatore viene utilizzato per separare le coppie chiave-valore e il `':'` delimitatore viene utilizzato per separare la chiave e il valore all'interno di ciascuna coppia. L'output di questa query è:. `{"a":"1","b":"2","c":"3"}` Questa è la struttura dei dati della mappa risultante, dove le chiavi sono `'a'` `'b'``'c'`, e, e i valori corrispondenti sono `'1'``'2'`, e`'3'`.
```
SELECT str_to_map('a:1,b:2,c:3', ',', ':');
{"a":"1","b":"2","c":"3"}
```
L'esempio seguente dimostra che la funzione STR\$1TO\$1MAP prevede che la stringa di input sia in un formato specifico, con le coppie chiave-valore delimitate correttamente. Se la stringa di input non corrisponde al formato previsto, la funzione tenterà comunque di creare una mappa, ma i valori risultanti potrebbero non essere quelli previsti.
```
SELECT str_to_map('a');
{"a":null}
```
# TO\$1CHAR
TO\$1CHAR converte un timestamp o un'espressione numerica in un formato di dati carattere-stringa.
## Sintassi
```
TO_CHAR (timestamp_expression | numeric_expression , 'format')
```
## Arguments (Argomenti)
*timestamp\$1expression*
Un'espressione che restituisce un valore di tipo TIMESTAMP o TIMESTAMPTZ o un valore che può essere implicitamente costretto in un timestamp.
*numeric\$1expression*
Un'espressione che restituisce un valore di tipo di dati numerici un valore che può essere implicitamente costretto in un tipo numerico. Per ulteriori informazioni, consulta [Tipi numerici](Numeric_types.md). TO\$1CHAR inserisce uno spazio a sinistra della stringa numerica.
TO\$1CHAR non supporta valori DECIMALI a 128 bit.
*format*
Il formato per il nuovo valore. Per i formati validi, consultare [Stringhe di formato datetime](FORMAT_strings.md) e [Stringhe di formato numerico](Numeric_formating.md).
## Tipo restituito
VARCHAR
## Esempi
Nell'esempio seguente un timestamp viene convertito in un valore con la data e l'ora in un formato con il nome del mese a nove caratteri, il nome del giorno della settimana e il numero del giorno del mese.
```
select to_char(timestamp '2009-12-31 23:15:59', 'MONTH-DY-DD-YYYY HH12:MIPM');
to_char
-------------------------
DECEMBER -THU-31-2009 11:15PM
```
Nell'esempio seguente un timestamp viene convertito in un valore con il numero di giorno dell'anno.
```
select to_char(timestamp '2009-12-31 23:15:59', 'DDD');
to_char
-------------------------
365
```
Nell'esempio seguente un timestamp viene convertito in un numero di giorno ISO della settimana.
```
select to_char(timestamp '2022-05-16 23:15:59', 'ID');
to_char
-------------------------
1
```
L'esempio seguente estrae il nome del mese da un valore di data.
```
select to_char(date '2009-12-31', 'MONTH');
to_char
-------------------------
DECEMBER
```
Nell'esempio seguente viene convertito ogni valore STARTTIME nella tabella EVENT in una stringa composta da ore, minuti e secondi.
```
select to_char(starttime, 'HH12:MI:SS')
from event where eventid between 1 and 5
order by eventid;
to_char
----------
02:30:00
08:00:00
02:30:00
02:30:00
07:00:00
(5 rows)
```
L'esempio seguente converte un intero valore timestamp in un formato diverso.
```
select starttime, to_char(starttime, 'MON-DD-YYYY HH12:MIPM')
from event where eventid=1;
starttime | to_char
---------------------+---------------------
2008-01-25 14:30:00 | JAN-25-2008 02:30PM
(1 row)
```
L'esempio seguente converte un letterale di timestamp in una stringa di caratteri.
```
select to_char(timestamp '2009-12-31 23:15:59','HH24:MI:SS');
to_char
----------
23:15:59
(1 row)
```
L'esempio seguente converte un numero in una stringa di caratteri con il segno negativo alla fine.
```
select to_char(-125.8, '999D99S');
to_char
---------
125.80-
(1 row)
```
L'esempio seguente converte un numero in una stringa di caratteri con il simbolo di valuta.
```
select to_char(-125.88, '$S999D99');
to_char
---------
$-125.88
(1 row)
```
L'esempio seguente converte un numero in una stringa di caratteri con parentesi angolari per i numeri negativi.
```
select to_char(-125.88, '$999D99PR');
to_char
---------
$<125.88>
(1 row)
```
L'esempio seguente converte un numero in una stringa di numeri romani.
```
select to_char(125, 'RN');
to_char
---------
CXXV
(1 row)
```
L'esempio seguente mostra il giorno della settimana.
```
SELECT to_char(current_timestamp, 'FMDay, FMDD HH12:MI:SS');
to_char
-----------------------
Wednesday, 31 09:34:26
```
L'esempio seguente visualizza il suffisso numerico ordinale per un numero.
```
SELECT to_char(482, '999th');
to_char
-----------------------
482nd
```
L'esempio seguente sottrae la commissione dal prezzo pagato nella tabella delle vendite. La differenza viene quindi arrotondata per eccesso e convertita in un numero romano, mostrato nella colonna: `to_char`
```
select salesid, pricepaid, commission, (pricepaid - commission)
as difference, to_char(pricepaid - commission, 'rn') from sales
group by sales.pricepaid, sales.commission, salesid
order by salesid limit 10;
salesid | pricepaid | commission | difference | to_char
---------+-----------+------------+------------+-----------------
1 | 728.00 | 109.20 | 618.80 | dcxix
2 | 76.00 | 11.40 | 64.60 | lxv
3 | 350.00 | 52.50 | 297.50 | ccxcviii
4 | 175.00 | 26.25 | 148.75 | cxlix
5 | 154.00 | 23.10 | 130.90 | cxxxi
6 | 394.00 | 59.10 | 334.90 | cccxxxv
7 | 788.00 | 118.20 | 669.80 | dclxx
8 | 197.00 | 29.55 | 167.45 | clxvii
9 | 591.00 | 88.65 | 502.35 | dii
10 | 65.00 | 9.75 | 55.25 | lv
(10 rows)
```
L'esempio seguente aggiunge il simbolo della valuta ai valori di differenza mostrati nella `to_char` colonna:
```
select salesid, pricepaid, commission, (pricepaid - commission)
as difference, to_char(pricepaid - commission, 'l99999D99') from sales
group by sales.pricepaid, sales.commission, salesid
order by salesid limit 10;
salesid | pricepaid | commission | difference | to_char
--------+-----------+------------+------------+------------
1 | 728.00 | 109.20 | 618.80 | $ 618.80
2 | 76.00 | 11.40 | 64.60 | $ 64.60
3 | 350.00 | 52.50 | 297.50 | $ 297.50
4 | 175.00 | 26.25 | 148.75 | $ 148.75
5 | 154.00 | 23.10 | 130.90 | $ 130.90
6 | 394.00 | 59.10 | 334.90 | $ 334.90
7 | 788.00 | 118.20 | 669.80 | $ 669.80
8 | 197.00 | 29.55 | 167.45 | $ 167.45
9 | 591.00 | 88.65 | 502.35 | $ 502.35
10 | 65.00 | 9.75 | 55.25 | $ 55.25
(10 rows)
```
L'esempio seguente elenca il secolo in cui è stata effettuata ciascuna vendita.
```
select salesid, saletime, to_char(saletime, 'cc') from sales
order by salesid limit 10;
salesid | saletime | to_char
---------+---------------------+---------
1 | 2008-02-18 02:36:48 | 21
2 | 2008-06-06 05:00:16 | 21
3 | 2008-06-06 08:26:17 | 21
4 | 2008-06-09 08:38:52 | 21
5 | 2008-08-31 09:17:02 | 21
6 | 2008-07-16 11:59:24 | 21
7 | 2008-06-26 12:56:06 | 21
8 | 2008-07-10 02:12:36 | 21
9 | 2008-07-22 02:23:17 | 21
10 | 2008-08-06 02:51:55 | 21
(10 rows)
```
Nell'esempio seguente viene convertito ogni valore STARTTIME nella tabella EVENT in una stringa composta da ore, minuti, secondi e fuso orario.
```
select to_char(starttime, 'HH12:MI:SS TZ')
from event where eventid between 1 and 5
order by eventid;
to_char
----------
02:30:00 UTC
08:00:00 UTC
02:30:00 UTC
02:30:00 UTC
07:00:00 UTC
(5 rows)
(10 rows)
```
L'esempio seguente mostra la formattazione per secondi, millisecondi e microsecondi.
```
select sysdate,
to_char(sysdate, 'HH24:MI:SS') as seconds,
to_char(sysdate, 'HH24:MI:SS.MS') as milliseconds,
to_char(sysdate, 'HH24:MI:SS:US') as microseconds;
timestamp | seconds | milliseconds | microseconds
--------------------+----------+--------------+----------------
2015-04-10 18:45:09 | 18:45:09 | 18:45:09.325 | 18:45:09:325143
```
# Funzione TO\$1DATE
TO\$1DATE converte una data rappresentata con una stringa di caratteri in un tipo di dati DATE.
## Sintassi
```
TO_DATE (date_str)
```
```
TO_DATE (date_str, format)
```
## Arguments (Argomenti)
*data\$1str*
Una stringa di data o un tipo di dati che può essere inserito in una stringa di date.
*format*
Una stringa letterale che corrisponde ai modelli datetime di Spark. Per modelli datetime validi, vedi [Datetime Patterns for Formatting and Parsing](https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html).
## Tipo restituito
TO\$1DATE restituisce una DATA, in base al valore *formato*.
Se la conversione in *formato* non riesce, viene restituito un errore.
## Esempi
L'istruzione SQL seguente converte la data `02 Oct 2001` in un tipo di dati data.
```
select to_date('02 Oct 2001', 'dd MMM yyyy');
to_date
------------
2001-10-02
(1 row)
```
L'istruzione SQL seguente converte la stringa `20010631` in una data.
```
select to_date('20010631', 'yyyyMMdd');
```
L'istruzione SQL seguente converte la stringa `20010631` in una data:
```
to_date('20010631', 'YYYYMMDD', TRUE);
```
Il risultato è un valore nullo perché ci sono solo 30 giorni a giugno.
```
to_date
------------
NULL
```
# TO\$1NUMBER
TO\$1NUMBER converte una stringa in un valore numerico (decimale).
## Sintassi
```
to_number(string, format)
```
## Arguments (Argomenti)
*stringa*
Stringa da convertire. Il formato deve essere un valore letterale.
*format*
Il secondo argomento è una stringa di formato che indica come deve essere analizzata la stringa di caratteri per creare il valore numerico. Ad esempio, il formato `'99D999'` specifica che la stringa da convertire è composta da cinque cifre con il punto decimale nella terza posizione. Ad esempio, `to_number('12.345','99D999')` restituisce `12.345` come valore numerico. Per un elenco di formati validi, consultare [Stringhe di formato numerico](Numeric_formating.md).
## Tipo restituito
TO\$1NUMBER restituisce un numero DECIMAL.
Se la conversione in *formato* non riesce, viene restituito un errore.
## Esempi
L'esempio seguente converte la stringa `12,454.8-` in un numero:
```
select to_number('12,454.8-', '99G999D9S');
to_number
-----------
-12454.8
```
L'esempio seguente converte la stringa `$ 12,454.88` in un numero:
```
select to_number('$ 12,454.88', 'L 99G999D99');
to_number
-----------
12454.88
```
L'esempio seguente converte la stringa `$ 2,012,454.88` in un numero:
```
select to_number('$ 2,012,454.88', 'L 9,999,999.99');
to_number
-----------
2012454.88
```
# UNBASE64 funzione
La UNBASE64 funzione converte un argomento da una stringa in base 64 a un file binario.
La codifica Base64 viene comunemente utilizzata per rappresentare dati binari (come immagini, file o informazioni crittografate) in un formato testuale sicuro per la trasmissione su vari canali di comunicazione (come e-mail, parametri URL o archiviazione di database).
La UNBASE64 funzione consente di invertire questo processo e ripristinare i dati binari originali. Questo tipo di funzionalità può essere utile in scenari in cui è necessario lavorare con dati codificati in formato Base64, ad esempio durante l'integrazione con sistemi esterni o APIs che utilizzano Base64 come meccanismo di trasferimento dei dati.
## Sintassi
```
unbase64(expr)
```
## Arguments (Argomenti)
*expr*
Un'espressione STRING in formato base64.
## Tipo restituito
`BINARY`
## Esempio
Nell'esempio seguente, la stringa con codifica Base64 `'U3BhcmsgU1FM'` viene riconvertita nella stringa originale. `'Spark SQL'`
```
SELECT unbase64('U3BhcmsgU1FM');
Spark SQL
```
# Funzione UNHEX
La funzione UNHEX riconverte una stringa esadecimale nella sua rappresentazione di stringa originale.
Questa funzione può essere utile in scenari in cui è necessario lavorare con dati archiviati o trasmessi in formato esadecimale e ripristinare la rappresentazione di stringa originale per un'ulteriore elaborazione o visualizzazione.
[La funzione UNHEX è la controparte della funzione HEX.](HEX.md)
## Sintassi
```
unhex(expr)
```
## Arguments (Argomenti)
*expr*
Un'espressione STRING di caratteri esadecimali.
## Tipo restituito
UNHEX restituisce un valore BINARIO.
Se la lunghezza di *expr* è dispari, il primo carattere viene scartato e al risultato viene aggiunto un byte nullo. Se *expr* contiene caratteri non esadecimali, il risultato è NULL.
## Esempio
L'esempio seguente converte una stringa esadecimale nella sua rappresentazione di stringa originale utilizzando insieme le funzioni UNHEX () e DECODE (). La prima parte della query utilizza la funzione UNHEX () per convertire la stringa esadecimale '537061726B2053514C' nella sua rappresentazione binaria. La seconda parte della query utilizza la funzione DECODE () per convertire i dati binari ottenuti dalla funzione UNHEX () in una stringa, utilizzando la codifica dei caratteri 'UTF-8'. L'output della query è la stringa originale 'Spark\$1SQL' che è stata convertita in formato esadecimale e poi nuovamente in una stringa.
```
SELECT decode(unhex('537061726B2053514C'), 'UTF-8');
Spark SQL
```
# Stringhe di formato datetime
È possibile utilizzare i modelli datetime nei seguenti scenari comuni:
+ Quando si lavora con fonti di dati CSV e JSON per analizzare e formattare il contenuto datetime
+ Durante la conversione tra tipi di stringhe e tipi di data o timestamp utilizzando funzioni come:
+ unix\$1timestamp
+ date\$1format
+ to\$1unix\$1timestamp
+ da\$1unixtime
+ to\$1date
+ to\$1timestamp
+ da\$1utc\$1timestamp
+ to\$1utc\$1timestamp
Utilizza lo schema di lettere nella tabella seguente per l'analisi e la formattazione di data e ora.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/clean-rooms/latest/sql-reference/FORMAT_strings.html)
Il numero di lettere dello schema determina il tipo di formato:
Formato del testo
+ Usa 1-3 lettere per la forma abbreviata (ad esempio, «lun» per lunedì)
+ Usa esattamente 4 lettere per il modulo completo (ad esempio, «lunedì»)
+ Non utilizzare 5 o più lettere: ciò causerà un errore
Formato numerico (n)
+ Il valore n rappresenta il numero massimo di lettere consentito
+ Per modelli a lettera singola:
+ L'output utilizza un numero minimo di cifre senza imbottitura
+ Per modelli con più lettere:
+ L'output è riempito con zeri in base alla larghezza del conteggio delle lettere
+ Durante l'analisi, l'input deve contenere il numero esatto di cifre
Formato numerico/testo
+ Per 3 o più lettere, segui le regole del formato del testo
+ Per un numero inferiore di lettere, segui le regole del formato numerico
Formato delle frazioni
+ Usa 1-9 caratteri «S» (ad esempio, SSSSSS)
+ Per l'analisi:
+ Accetta frazioni comprese tra 1 e il numero di caratteri S
+ Per la formattazione:
+ Tasto con zeri corrispondente al numero di caratteri S
+ Supporta fino a 6 cifre per una precisione al microsecondo
+ Può analizzare i nanosecondi ma tronca le cifre aggiuntive
Formato dell'anno
+ Il conteggio delle lettere imposta la larghezza minima del campo per il riempimento
+ Per due lettere:
+ Stampa le ultime due cifre
+ Analizza gli anni compresi tra il 2000 e il 2099
+ Per meno di quattro lettere (tranne due):
+ Mostra il segno solo per gli anni negativi
+ Non utilizzare 7 o più lettere: ciò causerà un errore
Formato mensile
+ Usa «M» per il modulo standard o «L» per il modulo autonomo
+ Singola «M» o «L»:
+ Mostra i numeri dei mesi da 1 a 12 senza imbottitura
+ 'MM' o 'LL':
+ Mostra i numeri dei mesi 01-12 con imbottitura
+ 'MMM':
+ Mostra il nome abbreviato del mese in formato standard
+ Deve far parte di uno schema di data completo
+ 'LLL':
+ Mostra il nome abbreviato del mese in forma autonoma
+ Utilizzare per la formattazione solo per un mese
+ 'MMMM':
+ Mostra il nome completo del mese in formato standard
+ Utilizza per date e timestamp
+ 'LLLL':
+ Mostra il nome completo del mese in forma autonoma
+ Utilizza per la formattazione solo per un mese
Formati di fuso orario
+ am-pm: usa solo 1 lettera
+ ID zona (V): utilizza solo 2 lettere
+ Nomi delle zone (z):
+ 1-3 lettere: mostra il nome breve
+ 4 lettere: mostra il nome completo
+ Non utilizzare 5 o più lettere
Formati offset
+ X e x:
+ 1 lettera: indica l'ora (\$101) o l'ora-minuto (\$10130)
+ 2 lettere: mostra le ore e i minuti senza i due punti (\$10130)
+ 3 lettere: mostra l'ora e i minuti con i due punti (\$1 01:30)
+ 4 lettere: mostra hour-minute-second senza due punti (\$1013015)
+ 5 lettere: mostra hour-minute-second con i due punti (\$1 01:30:15)
+ X usa 'Z' per l'offset zero
+ x usa '\$100', '\$10000' o '\$1 00:00 'per l'offset zero
+ O:
+ 1 lettera: mostra il formato breve (GMT\$18)
+ 4 lettere: mostra il modulo completo (GMT\$1 08:00)
+ Z:
+ 1-3 lettere: mostra l'ora e il minuto senza i due punti (\$10130)
+ 4 lettere: mostra il modulo localizzato completo
+ 5 lettere: mostra hour-minute-second con i due punti
Sezioni opzionali
+ Usa le parentesi quadre [] per contrassegnare il contenuto opzionale
+ È possibile annidare sezioni opzionali
+ Tutti i dati validi vengono visualizzati nell'output
+ L'input può omettere intere sezioni opzionali
**Nota**
I simboli 'E', 'F', 'q' e 'Q' funzionano solo per la formattazione della data e dell'ora (come date\$1format). Non usarli per l'analisi della data e dell'ora (come to\$1timestamp).
# Stringhe di formato numerico
Le seguenti stringhe di formato numerico si applicano a funzioni come TO\$1NUMBER e TO\$1CHAR.
+ Per esempi di formattazione di stringhe come numeri, consulta [TO\$1NUMBER](TO_NUMBER.md).
+ Per esempi di formattazione di numeri come stringhe, consulta [TO\$1CHAR](TO_CHAR.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/clean-rooms/latest/sql-reference/Numeric_formating.html)
# Funzioni di data e ora
Le funzioni di data e ora consentono di eseguire un'ampia gamma di operazioni sui dati di data e ora, ad esempio estrarre parti di una data, eseguire calcoli di date, formattare date e ore e lavorare con la data e l'ora correnti. Queste funzioni sono essenziali per attività quali l'analisi dei dati, la creazione di report e la manipolazione dei dati che coinvolgono dati temporali.
AWS Clean Rooms supporta le seguenti funzioni di data e ora:
**Topics**
+ [Funzione ADD\$1MONTHS](ADD_MONTHS.md)
+ [Funzione CONVERT\$1TIMEZONE](s_CONVERT_TIMEZONE.md)
+ [Funzione CURRENT\$1DATE](CURRENT_DATE_function.md)
+ [Funzione CURRENT\$1TIMESTAMP](CURRENT_TIMESTAMP.md)
+ [Funzione DATE\$1ADD](DATE_ADD_function.md)
+ [Funzione DATE\$1DIFF](DATE_DIFF_function.md)
+ [Funzione DATE\$1PART](DATE_PART_function.md)
+ [Funzione DATE\$1TRUNC](DATE_TRUNC.md)
+ [Funzione DAY](DAY.md)
+ [Funzione DAYOFMONTH](DAYOFMONTH.md)
+ [Funzione DAYOFWEEK](DAYOFWEEK.md)
+ [funzione DAYOFYEAR](DAYOFYEAR.md)
+ [Funzione EXTRACT](EXTRACT_function.md)
+ [funzione FROM\$1UTC\$1TIMESTAMP](FROM_UTC_TIMESTAMP.md)
+ [Funzione HOUR](HOUR.md)
+ [Funzione MINUTE](MINUTE.md)
+ [Funzione MONTH](MONTH.md)
+ [Funzione SECOND](SECOND.md)
+ [Funzione TIMESTAMP](TIMESTAMP.md)
+ [Funzione TO\$1TIMESTAMP](TO_TIMESTAMP.md)
+ [funzione YEAR](YEAR.md)
+ [Parti di data per funzioni di data e timestamp](Dateparts_for_datetime_functions.md)
# Funzione ADD\$1MONTHS
ADD\$1MONTHS aggiunge il numero di mesi specificato a un valore o espressione di data o timestamp. La funzione [DATE\$1ADD](DATE_ADD_function.md) fornisce una funzionalità simile.
## Sintassi
```
ADD_MONTHS( {date | timestamp}, integer)
```
## Arguments (Argomenti)
*date* \$1 *timestamp*
Un'espressione o una colonna data o timestamp che viene implicitamente convertita in una data o un timestamp. Se la data è l'ultimo giorno del mese o se il mese risultante è più corto, la funzione restituisce l'ultimo giorno del mese nel risultato. Per le altre date, il risultato contiene lo stesso numero di giorni dell'espressione di data.
*integer*
Un integer positivo o negativo. Utilizza un numero negativo per sottrarre mesi dalle date.
## Tipo restituito
TIMESTAMP
## Esempio
La query seguente utilizza la funzione ADD\$1MONTHS in una funzione TRUNC. La funzione TRUNC rimuove l'ora del giorno dal risultato di ADD\$1MONTHS. La funzione ADD\$1MONTHS aggiunge 12 mesi a ogni valore della colonna CALDATE.
```
select distinct trunc(add_months(caldate, 12)) as calplus12,
trunc(caldate) as cal
from date
order by 1 asc;
calplus12 | cal
------------+------------
2009-01-01 | 2008-01-01
2009-01-02 | 2008-01-02
2009-01-03 | 2008-01-03
...
(365 rows)
```
Gli esempi seguenti illustrano il comportamento quando la funzione ADD\$1MONTHS opera su date con mesi che hanno un numero di giorni differente.
```
select add_months('2008-03-31',1);
add_months
---------------------
2008-04-30 00:00:00
(1 row)
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
(1 row)
```
# Funzione CONVERT\$1TIMEZONE
CONVERT\$1TIMEZONE converte un timestamp da un fuso orario a un altro. La funzione si regola automaticamente in base all’ora legale.
## Sintassi
```
CONVERT_TIMEZONE ( ['source_timezone',] 'target_timezone', 'timestamp')
```
## Arguments (Argomenti)
*source\$1timezone*
(Facoltativo) Il fuso orario del timestamp corrente. Il valore predefinito è UTC.
*target\$1timezone*
Il fuso orario del nuovo timestamp.
*timestamp*
Una colonna timestamp o un'espressione che viene implicitamente convertita in un timestamp.
## Tipo restituito
TIMESTAMP
## Esempi
L'esempio seguente converte il valore di timestamp dal fuso orario UTC predefinito in PST.
```
select convert_timezone('PST', '2008-08-21 07:23:54');
convert_timezone
------------------------
2008-08-20 23:23:54
```
L'esempio seguente converte il valore di timestamp nella colonna LISTTIME dal fuso orario UTC predefinito in PST. Anche se il timestamp rientra nel periodo dell'ora legale, viene convertito nell'ora standard in quanto il fuso orario di destinazione è specificato come abbreviazione (PST).
```
select listtime, convert_timezone('PST', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+-------------------
2008-08-24 09:36:12 2008-08-24 01:36:12
```
L'esempio seguente converte una colonna LISTTIME con timestamp dal fuso orario UTC predefinito al fuso orario. US/Pacific Il fuso orario di destinazione utilizza un nome di fuso orario e il timestamp è nel periodo dell'ora legale, di conseguenza la funzione restituisce l'ora legale.
```
select listtime, convert_timezone('US/Pacific', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+---------------------
2008-08-24 09:36:12 | 2008-08-24 02:36:12
```
L'esempio seguente converte una stringa di timestamp da EST a PST:
```
select convert_timezone('EST', 'PST', '20080305 12:25:29');
convert_timezone
-------------------
2008-03-05 09:25:29
```
L'esempio seguente converte un timestamp all'ora standard degli Stati Uniti orientali in quanto il fuso orario di destinazione utilizza un nome di fuso orario (America/New\$1York) e il timestamp si trova nel periodo dell'ora standard.
```
select convert_timezone('America/New_York', '2013-02-01 08:00:00');
convert_timezone
---------------------
2013-02-01 03:00:00
(1 row)
```
L'esempio seguente converte il timestamp nell'ora legale dell'est degli Stati Uniti in quanto il fuso orario target utilizza un nome di fuso orario (America/New\$1York) e il timestamp si trova nel periodo dell'ora legale.
```
select convert_timezone('America/New_York', '2013-06-01 08:00:00');
convert_timezone
---------------------
2013-06-01 04:00:00
(1 row)
```
L'esempio seguente illustra l'utilizzo di offset.
```
SELECT CONVERT_TIMEZONE('GMT','NEWZONE +2','2014-05-17 12:00:00') as newzone_plus_2,
CONVERT_TIMEZONE('GMT','NEWZONE-2:15','2014-05-17 12:00:00') as newzone_minus_2_15,
CONVERT_TIMEZONE('GMT','America/Los_Angeles+2','2014-05-17 12:00:00') as la_plus_2,
CONVERT_TIMEZONE('GMT','GMT+2','2014-05-17 12:00:00') as gmt_plus_2;
newzone_plus_2 | newzone_minus_2_15 | la_plus_2 | gmt_plus_2
---------------------+---------------------+---------------------+---------------------
2014-05-17 10:00:00 | 2014-05-17 14:15:00 | 2014-05-17 10:00:00 | 2014-05-17 10:00:00
(1 row)
```
# Funzione CURRENT\$1DATE
CURRENT\$1DATE restituisce una data nel fuso orario della sessione corrente (UTC per impostazione predefinita) nel formato predefinito:. YYYY-MM-DD
**Nota**
CURRENT\$1DATE restituisce la data di inizio della transazione corrente e non dell'istruzione corrente. Considera lo scenario quando avvii una transazione contenente più istruzioni alle 23:59 del giorno 01/10/08 e l'istruzione contenente CURRENT\$1DATE viene eseguita alle 00:00 del 02/10/08. CURRENT\$1DATE restituisce `10/01/08`, non `10/02/08`.
## Sintassi
```
CURRENT_DATE
```
## Tipo restituito
DATE
## Esempio
L'esempio seguente restituisce la data corrente (nel punto in Regione AWS cui viene eseguita la funzione).
```
select current_date;
date
------------
2008-10-01
```
# Funzione CURRENT\$1TIMESTAMP
CURRENT\$1TIMESTAMP restituisce la data e l'ora correnti, incluse la data, l'ora e (facoltativamente) i millisecondi o i microsecondi.
Questa funzione è utile quando è necessario ottenere la data e l'ora correnti, ad esempio per registrare il timestamp di un evento, eseguire calcoli basati sul tempo o popolare le colonne. date/time
## Sintassi
```
current_timestamp()
```
## Tipo restituito
La funzione CURRENT\$1TIMESTAMP restituisce un valore DATE.
## Esempio
L'esempio seguente restituisce la data e l'ora correnti nel momento in cui viene eseguita la query, ovvero il 25 aprile 2020 alle 15:49:11.914 (3:49:11.914 PM).
```
SELECT current_timestamp();
2020-04-25 15:49:11.914
```
L'esempio seguente recupera la data e l'ora correnti per ogni riga della tabella. `squirrels`
```
SELECT current_timestamp() FROM squirrels
```
# Funzione DATE\$1ADD
Restituisce la data corrispondente a num\$1days dopo start\$1date.
## Sintassi
```
date_add(start_date, num_days)
```
## Arguments (Argomenti)
*data\$1iniziale*
Il valore della data di inizio.
*num\$1days*
Il numero di giorni da aggiungere (numero intero). Un numero positivo aggiunge giorni, un numero negativo sottrae giorni.
## Tipo restituito
DATE
## Esempi
L'esempio seguente aggiunge un giorno a una data:
```
SELECT date_add('2016-07-30', 1);
Result:
2016-07-31
```
L'esempio seguente aggiunge più giorni.
```
SELECT date_add('2016-07-30', 5);
Result:
2016-08-04
```
## Note per l'utilizzo
Questa documentazione riguarda la funzione DATE\$1ADD di Spark SQL, che fornisce un'interfaccia più semplice per aggiungere giorni alle date rispetto ad altre varianti SQL. Per aggiungere altri intervalli come mesi o anni, potrebbero essere necessarie funzioni diverse.
# Funzione DATE\$1DIFF
DATE\$1DIFF restituisce la differenza tra le parti relative alla data di due espressioni di data o ora.
## Sintassi
```
date_diff(endDate, startDate)
```
## Arguments (Argomenti)
*endDate*
Un'espressione DATE.
*startDate*
Un'espressione DATE.
## Tipo restituito
BIGINT
## Esempi con una colonna DATE
Nell'esempio seguente viene rilevata la differenza in numero di settimane tra due valori di data letterali.
```
select date_diff(week,'2009-01-01','2009-12-31') as numweeks;
numweeks
----------
52
(1 row)
```
Nell'esempio seguente viene rilevata la differenza in ore tra due valori di data letterali. Quando non si fornisce il valore dell'ora per una data, il valore predefinito è 00:00:00.
```
select date_diff(hour, '2023-01-01', '2023-01-03 05:04:03');
date_diff
----------
53
(1 row)
```
Nell'esempio seguente viene rilevata la differenza in giorni tra due valori TIMESTAMETZ letterali.
```
Select date_diff(days, 'Jun 1,2008 09:59:59 EST', 'Jul 4,2008 09:59:59 EST')
date_diff
----------
33
```
Nell'esempio seguente viene rilevata la differenza, in giorni, tra due date nella stessa riga di una tabella.
```
select * from date_table;
start_date | end_date
-----------+-----------
2009-01-01 | 2009-03-23
2023-01-04 | 2024-05-04
(2 rows)
select date_diff(day, start_date, end_date) as duration from date_table;
duration
---------
81
486
(2 rows)
```
Nel seguente esempio viene trovata la differenza, in numero di trimestri, tra un valore letterale nel passato e la data odierna. Questo esempio presuppone che la data corrente è il 5 giugno 2008. È possibile assegnare un nome completo o abbreviato alle parti di data. Il nome di colonna predefinito per la funzione DATE\$1DIFF è DATE\$1DIFF.
```
select date_diff(qtr, '1998-07-01', current_date);
date_diff
-----------
40
(1 row)
```
In questo esempio viene eseguito il join delle tabelle SALES e LISTING per calcolare quanti giorni dopo la pubblicazione sono stati venduti i biglietti per i risultati da 1000 a 1005. L'attesa più lunga per la vendita di questi elenchi è di 15 giorni e quella più breve è inferiore a 1 giorno (0 giorni).
```
select priceperticket,
date_diff(day, listtime, saletime) as wait
from sales, listing where sales.listid = listing.listid
and sales.listid between 1000 and 1005
order by wait desc, priceperticket desc;
priceperticket | wait
---------------+------
96.00 | 15
123.00 | 11
131.00 | 9
123.00 | 6
129.00 | 4
96.00 | 4
96.00 | 0
(7 rows)
```
Questo esempio calcola il numero medio di ore di attesa dei venditori per tutte le vendite di biglietti.
```
select avg(date_diff(hours, listtime, saletime)) as avgwait
from sales, listing
where sales.listid = listing.listid;
avgwait
---------
465
(1 row)
```
## Esempi con una colonna TIME
La tabella di esempio seguente TIME\$1TEST contiene una colonna TIME\$1VAL (tipo TIME) con tre valori inseriti.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Nell'esempio seguente viene rilevata la differenza di numero di ore tra la colonna TIME\$1VAL e un valore letterale temporale.
```
select date_diff(hour, time_val, time '15:24:45') from time_test;
date_diff
-----------
-5
15
15
```
Nell'esempio seguente viene rilevata la differenza in numero di minuti tra due valori letterali temporali.
```
select date_diff(minute, time '20:00:00', time '21:00:00') as nummins;
nummins
----------
60
```
## Esempi con una colonna TIMETZ
La tabella di esempio seguente TIMETZ\$1TEST contiene una colonna TIMETZ\$1VAL (tipo TIMETZ) con tre valori inseriti.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Nell'esempio seguente vengono individuate le differenze nel numero di ore, tra un letterale TIMETZ e timetz\$1val.
```
select date_diff(hours, timetz '20:00:00 PST', timetz_val) as numhours from timetz_test;
numhours
----------
0
-4
1
```
Nell'esempio seguente viene rilevata la differenza in numero di ore tra due valori TIMETZ letterali.
```
select date_diff(hours, timetz '20:00:00 PST', timetz '00:58:00 EST') as numhours;
numhours
----------
1
```
# Funzione DATE\$1PART
DATE\$1PART estrae valori di parte di data da un'espressione. DATE\$1PART è un sinonimo della funzione PGDATE\$1PART.
## Sintassi
```
datepart(field, source)
```
## Arguments (Argomenti)
*campo*
Quale parte del sorgente deve essere estratta e i valori di stringa supportati sono gli stessi dei campi della funzione equivalente EXTRACT.
*source (origine)*
Una colonna DATE o INTERVAL da cui estrarre il campo.
## Tipo restituito
Se il *campo* è 'SECOND', un DECIMAL (8, 6). In tutti gli altri casi, un numero INTERO.
## Esempio
L'esempio seguente estrae il giorno dell'anno (DOY) da un valore di data. L'output mostra che il giorno dell'anno per la data «2019-08-12" è. `224` Ciò significa che il 12 agosto 2019 è il 224° giorno dell'anno 2019.
```
SELECT datepart('doy', DATE'2019-08-12');
224
```
# Funzione DATE\$1TRUNC
La funzione DATE\$1TRUNC tronca un'espressione di timestamp o letterale in base alla parte di data specificata, ad esempio ora, settimana o mese.
## Sintassi
```
date_trunc(format, datetime)
```
## Arguments (Argomenti)
*format*
Il formato che rappresenta l'unità in cui troncare. I formati validi sono:
+ «YEAR», «YYYY»: tronca alla prima data dell'anno in cui cade la ts, la parte temporale sarà azzerata
+ «QUARTER»: viene troncato alla prima data del trimestre in cui rientra la ts, la parte temporale verrà azzerata
+ «MONTH», «MM», «MON»: tronca alla prima data del mese in cui cade ts, la parte temporale verrà azzerata
+ «SETTIMANA»: viene troncata al lunedì della settimana in cui cade la ts, la parte temporale verrà azzerata
+ «DAY», «DD»: azzera la parte temporale
+ «HOUR»: azzera il minuto e il secondo con la parte frazionaria
+ «MINUTO»: azzera il secondo con la parte frazionaria
+ «SECONDO»: azzera la seconda parte della frazione
+ «MILLISECOND»: azzera i microsecondi
+ «MICROSECOND»: tutto rimane
*ts*
Un valore datetime
## Tipo restituito
Restituisce il timestamp *ts* troncato all'unità specificata dal modello di formato
## Esempi
L'esempio seguente tronca un valore di data all'inizio dell'anno. L'output mostra che la data «2015-03-05" è stata troncata a «2015-01-01", che è l'inizio dell'anno 2015.
```
SELECT date_trunc('YEAR', '2015-03-05');
date_trunc
-----------
2015-01-01
```
# Funzione DAY
La funzione DAY restituisce il giorno del mese della data/ora.
Le funzioni di estrazione della data sono utili quando è necessario lavorare con componenti specifici di una data o di un timestamp, ad esempio quando si eseguono calcoli basati sulla data, si filtrano i dati o si formattano i valori delle date.
## Sintassi
```
day(date)
```
## Arguments (Argomenti)
*data*
Un'espressione DATE o TIMESTAMP.
## Valori restituiti
La funzione DAY restituisce un valore INTEGER.
## Esempi
L'esempio seguente estrae il giorno del mese (`30`) dalla data di input. `'2009-07-30'`
```
SELECT day('2009-07-30');
30
```
L'esempio seguente estrae il giorno del mese dalla `birthday` colonna della `squirrels` tabella e restituisce i risultati come output dell'istruzione SELECT. L'output di questa query sarà un elenco di valori giornalieri, uno per ogni riga della `squirrels` tabella, che rappresentano il giorno del mese per il compleanno di ogni scoiattolo.
```
SELECT day(birthday) FROM squirrels
```
# Funzione DAYOFMONTH
La funzione DAYOFMONTH restituisce il giorno del mese di date/timestamp (un valore compreso tra 1 e 31, a seconda del mese e dell'anno).
La funzione DAYOFMONTH è simile alla funzione DAY, ma hanno nomi e comportamenti leggermente diversi. La funzione DAY è più comunemente utilizzata, ma la funzione DAYOFMONTH può essere utilizzata come alternativa. Questo tipo di query può essere utile quando è necessario eseguire analisi o filtri basati sulla data su una tabella che contiene dati relativi a data o ora, ad esempio per estrarre componenti specifici di una data per ulteriori elaborazioni o report.
## Sintassi
```
dayofmonth(date)
```
## Arguments (Argomenti)
*data*
Un'espressione DATE o TIMESTAMP.
## Valori restituiti
La funzione DAYOFMONTH restituisce un valore INTEGER.
## Esempio
L'esempio seguente estrae il giorno del mese (`30`) dalla data di input. `'2009-07-30'`
```
SELECT dayofmonth('2009-07-30');
30
```
L'esempio seguente applica la funzione DAYOFMONTH alla `birthday` colonna della tabella. `squirrels` Per ogni riga della `squirrels` tabella, il giorno del mese dalla `birthday` colonna verrà estratto e restituito come output dell'istruzione SELECT. L'output di questa query sarà un elenco di valori giornalieri, uno per ogni riga della `squirrels` tabella, che rappresentano il giorno del mese per il compleanno di ogni scoiattolo.
```
SELECT dayofmonth(birthday) FROM squirrels
```
# Funzione DAYOFWEEK
La funzione DAYOFWEEK accetta una data o un timestamp come input e restituisce il giorno della settimana come numero (1 per domenica, 2 per lunedì,..., 7 per sabato).
Questa funzione di estrazione della data è utile quando è necessario utilizzare componenti specifici di una data o di un timestamp, ad esempio quando si eseguono calcoli basati sulla data, si filtrano i dati o si formattano i valori delle date.
## Sintassi
```
dayofweek(date)
```
## Arguments (Argomenti)
*data*
Un'espressione DATE o TIMESTAMP.
## Valori restituiti
La funzione DAYOFWEEK restituisce un numero INTERO dove
1 = domenica
2 = lunedì
3 = martedì
4 = mercoledì
5 = giovedì
6 = venerdì
7 = sabato
## Esempi
L'esempio seguente estrae il giorno della settimana da questa data, che è 5 (che rappresenta giovedì).
```
SELECT dayofweek('2009-07-30');
5
```
L'esempio seguente estrae il giorno della settimana dalla `birthday` colonna della `squirrels` tabella e restituisce i risultati come output dell'istruzione SELECT. L'output di questa query sarà un elenco di valori del giorno della settimana, uno per ogni riga della `squirrels` tabella, che rappresentano il giorno della settimana per il compleanno di ogni scoiattolo.
```
SELECT dayofweek(birthday) FROM squirrels
```
# funzione DAYOFYEAR
La funzione DAYOFYEAR è una funzione di estrazione della data che accetta una data o un timestamp come input e restituisce il giorno dell'anno (un valore compreso tra 1 e 366, a seconda dell'anno e se si tratta di un anno bisestile).
Questa funzione è utile quando è necessario lavorare con componenti specifici di una data o di un timestamp, ad esempio quando si eseguono calcoli basati sulla data, si filtrano i dati o si formattano i valori delle date.
## Sintassi
```
dayofyear(date)
```
## Arguments (Argomenti)
*data*
Un'espressione DATE o TIMESTAMP.
## Valori restituiti
La funzione DAYOFYEAR restituisce un numero INTERO (compreso tra 1 e 366, a seconda dell'anno e se si tratta di un anno bisestile).
## Esempi
L'esempio seguente estrae il giorno dell'anno () dalla data di input. `100` `'2016-04-09'`
```
SELECT dayofyear('2016-04-09');
100
```
L'esempio seguente estrae il giorno dell'anno dalla `birthday` colonna della `squirrels` tabella e restituisce i risultati come output dell'istruzione SELECT.
```
SELECT dayofyear(birthday) FROM squirrels
```
# Funzione EXTRACT
La funzione EXTRACT restituisce una parte di data o di ora da un valore TIMESTAMP, TIMESTAMPTZ, TIME o TIMETZ. Gli esempi includono un giorno, mese, ora, minuto, secondo, millisecondo o microsecondo da un timestamp.
## Sintassi
```
EXTRACT(datepart FROM source)
```
## Arguments (Argomenti)
*datepart*
Il sottocampo di una data o ora da estrarre, ad esempio un giorno, un mese, un anno, un'ora, un minuto, un secondo, un millisecondo o un microsecondo. Per un elenco dei valori possibili, consultare [Parti di data per funzioni di data e timestamp](Dateparts_for_datetime_functions.md).
*source (origine)*
Una colonna o un'espressione che restituisce un tipo di dati TIMESTAMP, TIMESTAMPTZ, TIME o TIMETZ.
## Tipo restituito
INTEGER se il valore di *origine* restituisce un tipo di dati TIMESTAMP, TIME o TIMETZ.
DOUBLE PRECISION se il valore di *origine* restituisce il tipo di dati TIMESTAMPTZ.
## Esempi con TIME
La tabella di esempio seguente TIME\$1TEST ha una colonna TIME\$1VAL (tipo TIME) con tre valori inseriti.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Nell'esempio seguente vengono estratti i minuti da ogni timetz\$1val.
```
select extract(minute from time_val) as minutes from time_test;
minutes
-----------
0
0
58
```
Nell'esempio seguente vengono estratte le ore da ogni time\$1val.
```
select extract(hour from time_val) as hours from time_test;
hours
-----------
20
0
0
```
# funzione FROM\$1UTC\$1TIMESTAMP
La funzione FROM\$1UTC\$1TIMESTAMP converte la data di input da UTC (Coordinated Universal Time) al fuso orario specificato.
Questa funzione è utile quando è necessario convertire i valori di data e ora da UTC a un fuso orario specifico. Questo può essere importante quando si lavora con dati che provengono da diverse parti del mondo e devono essere presentati nell'ora locale appropriata.
## Sintassi
```
from_utc_timestamp(timestamp, timezone
```
## Arguments (Argomenti)
*timestamp*
Un'espressione TIMESTAMP con un timestamp UTC.
*timezone*
Un'espressione STRING che è un fuso orario valido in cui convertire la data o il timestamp di input.
## Valori restituiti
La funzione FROM\$1UTC\$1TIMESTAMP restituisce un TIMESTAMP.
## Esempio
L'esempio seguente converte la data di input da UTC al fuso orario specificato (`'Asia/Seoul'`), che in questo caso è 9 ore prima dell'UTC. L'output risultante è la data e l'ora nel fuso orario di Seoul, che è. `2016-08-31 09:00:00`
```
SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');
2016-08-31 09:00:00
```
# Funzione HOUR
La funzione HOUR è una funzione di estrazione temporale che richiede un orario o un timestamp come input e restituisce il componente orario (un valore compreso tra 0 e 23).
Questa funzione di estrazione temporale è utile quando è necessario lavorare con componenti specifici di un orario o di un timestamp, ad esempio quando si eseguono calcoli basati sul tempo, si filtrano i dati o si formattano i valori temporali.
## Sintassi
```
hour(timestamp)
```
## Arguments (Argomenti)
*timestamp*
UN'ESPRESSIONE TIMESTAMP.
## Valori restituiti
La funzione HOUR restituisce un valore INTEGER.
## Esempio
L'esempio seguente estrae il componente hour (`12`) dal timestamp di input. `'2009-07-30 12:58:59'`
```
SELECT hour('2009-07-30 12:58:59');
12
```
# Funzione MINUTE
La funzione MINUTE è una funzione di estrazione temporale che richiede un orario o un timestamp come input e restituisce il componente dei minuti (un valore compreso tra 0 e 60).
## Sintassi
```
minute(timestamp)
```
## Arguments (Argomenti)
*timestamp*
Un'espressione TIMESTAMP o una STRING di un formato di timestamp valido.
## Valori restituiti
La funzione MINUTE restituisce un valore INTEGER.
## Esempio
L'esempio seguente estrae il componente minute (`58`) dal timestamp di input. `'2009-07-30 12:58:59'`
```
SELECT minute('2009-07-30 12:58:59');
58
```
# Funzione MONTH
La funzione MONTH è una funzione di estrazione temporale che richiede un orario o un timestamp come input e restituisce il componente del mese (un valore compreso tra 0 e 12).
## Sintassi
```
month(date)
```
## Arguments (Argomenti)
*data*
Un'espressione TIMESTAMP o una STRING di un formato di timestamp valido.
## Valori restituiti
La funzione MONTH restituisce un valore INTEGER.
## Esempio
L'esempio seguente estrae il componente month (`7`) dal timestamp di input. `'2016-07-30'`
```
SELECT month('2016-07-30');
7
```
# Funzione SECOND
La funzione SECOND è una funzione di estrazione temporale che richiede un orario o un timestamp come input e restituisce il secondo componente (un valore compreso tra 0 e 60).
## Sintassi
```
second(timestamp)
```
## Arguments (Argomenti)
*timestamp*
Un'espressione TIMESTAMP.
## Valori restituiti
La funzione SECOND restituisce un valore INTEGER.
## Esempio
L'esempio seguente estrae il secondo componente (`59`) dal timestamp di input. `'2009-07-30 12:58:59'`
```
SELECT second('2009-07-30 12:58:59');
59
```
# Funzione TIMESTAMP
La funzione TIMESTAMP accetta un valore (in genere un numero) e lo converte in un tipo di dati timestamp.
Questa funzione è utile quando è necessario convertire un valore numerico che rappresenta un'ora o una data in un tipo di dati timestamp. Ciò può essere utile quando si lavora con dati archiviati in un formato numerico, ad esempio timestamp Unix o epoch time.
## Sintassi
```
timestamp(expr)
```
## Arguments (Argomenti)
*expr*
Qualsiasi espressione che può essere trasmessa a TIMESTAMP.
## Valori restituiti
La funzione TIMESTAMP restituisce un TIMESTAMP.
## Esempio
L'esempio seguente converte un timestamp numerico Unix (`1632416400`) nel tipo di dati timestamp corrispondente: 22 settembre 2021 alle 12:00:00 UTC.
```
SELECT timestamp(1632416400);
2021-09-22 12:00:00 UTC
```
# Funzione TO\$1TIMESTAMP
TO\$1TIMESTAMP converte una stringa TIMESTAMP in TIMESTAMPTZ.
## Sintassi
```
to_timestamp (timestamp)
```
```
to_timestamp (timestamp, format)
```
## Arguments (Argomenti)
*timestamp*
Una stringa di timestamp o un tipo di dati che può essere inserito in una stringa di timestamp.
*format*
Una stringa letterale che corrisponde ai modelli datetime di Spark. Per modelli datetime validi, vedi [Datetime Patterns for Formatting and Parsing](https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html).
## Tipo restituito
TIMESTAMP
## Esempi
L'esempio seguente dimostra l'utilizzo della funzione TO\$1TIMESTAMP per convertire una stringa TIMESTAMP in un TIMESTAMP.
```
select current_timestamp() as timestamp, to_timestamp( current_timestamp(), 'YYYY-MM-DD HH24:MI:SS') as second;
timestamp | second
-------------------------- ----------------------
2021-04-05 19:27:53.281812 | 2021-04-05 19:27:53+00
```
È possibile passare a TO\$1TIMESTAMP parte di una data. Le parti rimanenti della data sono impostate sui valori predefiniti. L'orario è incluso nell'output:
```
SELECT TO_TIMESTAMP('2017','YYYY');
to_timestamp
--------------------------
2017-01-01 00:00:00+00
```
La seguente istruzione SQL converte la stringa '2011-12-18 24:38:15 'in un TIMESTAMP. Il risultato è un TIMESTAMP che cade il giorno successivo perché il numero di ore è superiore a 24 ore:
```
select to_timestamp('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS');
to_timestamp
----------------------
2011-12-19 00:38:15+00
```
# funzione YEAR
La funzione YEAR è una funzione di estrazione della data che accetta una data o un timestamp come input e restituisce il componente dell'anno (un numero a quattro cifre).
## Sintassi
```
year(date)
```
## Arguments (Argomenti)
*data*
Un'espressione DATE o TIMESTAMP.
## Valori restituiti
La funzione YEAR restituisce un valore INTEGER.
## Esempio
L'esempio seguente estrae il componente year (`2016`) dalla data di input. `'2016-07-30'`
```
SELECT year('2016-07-30');
2016
```
L'esempio seguente estrae il componente year dalla `birthday` colonna della `squirrels` tabella e restituisce i risultati come output dell'istruzione SELECT. L'output di questa query sarà un elenco di valori annuali, uno per ogni riga della `squirrels` tabella, che rappresentano l'anno di nascita di ogni scoiattolo.
```
SELECT year(birthday) FROM squirrels
```
# Parti di data per funzioni di data e timestamp
La tabella seguente identifica i nomi e le abbreviazioni di parti di data e parti di ora accettati come argomenti per le seguenti funzioni:
+ DATE\$1ADD
+ DATE\$1DIFF
+ DATE\$1PART
+ EXTRACT
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/clean-rooms/latest/sql-reference/Dateparts_for_datetime_functions.html)
## Variazioni nei risultati con secondi, millisecondi e microsecondi
Differenze minori nei risultati delle query si hanno quando funzioni di data differenti specificano secondi, millisecondi o microsecondi come parti di data:
+ La funzione EXTRACT restituisce interi solo per la parte di data specificata, ignorando parti di dati di livello superiore e inferiore. Se la parte di data specificata è secondi, millisecondi e microsecondi non sono inclusi nel risultato. Se la parte di data specificata è millisecondi, secondi e microsecondi non sono inclusi nel risultato. Se la parte di data specificata è microsecondi, secondi e millisecondi non sono inclusi nel risultato.
+ La funzione DATE\$1PART restituisce la parte di secondi completa del timestamp, indipendentemente dalla parte di data specificata, restituendo un valore decimale o un intero in base alle necessità.
## Note su CENTURY, EPOCH, DECADE e MIL
CENTURY o CENTURIES
AWS Clean Rooms interpreta un CENTURY in modo che inizi con l'anno *\$1\$1 \$11* e finisca con l'anno: `###0`
```
select extract (century from timestamp '2000-12-16 12:21:13');
date_part
-----------
20
(1 row)
select extract (century from timestamp '2001-12-16 12:21:13');
date_part
-----------
21
(1 row)
```
EPOCA
L' AWS Clean Rooms implementazione di EPOCH è relativa al 1970-01-01 00:00:00.000 000 indipendentemente dal fuso orario in cui risiede il cluster. È possibile che sia necessario compensare i risultati della differenza in ore a seconda del fuso orario in cui si trova il cluster.
DECADE o DECADES
AWS Clean Rooms interpreta DECADE o DECADES DATEPART in base al calendario comune. Ad esempio, poiché il calendario comune inizia dall'anno 1, il primo decennio (decennio 1) va da 0001-01-01 a 0009-12-31 e il secondo decennio (decennio 2) va da 0010-01-01 a 0019-12-31. Ad esempio, il decennio 201 va da 2000-01-01 a 2009-12-31:
```
select extract(decade from timestamp '1999-02-16 20:38:40');
date_part
-----------
200
(1 row)
select extract(decade from timestamp '2000-02-16 20:38:40');
date_part
-----------
201
(1 row)
select extract(decade from timestamp '2010-02-16 20:38:40');
date_part
-----------
202
(1 row)
```
MIL o MILS
AWS Clean Rooms interpreta un MIL in modo che inizi con il primo giorno dell'anno *\$1001* e finisca con l'ultimo giorno dell'anno: `#000`
```
select extract (mil from timestamp '2000-12-16 12:21:13');
date_part
-----------
2
(1 row)
select extract (mil from timestamp '2001-12-16 12:21:13');
date_part
-----------
3
(1 row)
```
# Funzioni di crittografia e decrittografia
Le funzioni di crittografia e decrittografia aiutano gli sviluppatori SQL a proteggere i dati sensibili dall'accesso non autorizzato o dall'uso improprio convertendoli tra un formato di testo semplice leggibile e un formato di testo cifrato illeggibile.
AWS Clean Rooms Spark SQL supporta le seguenti funzioni di crittografia e decrittografia:
**Topics**
+ [Funzione AES\$1ENCRYPT](AES_ENCRYPT.md)
+ [Funzione AES\$1DECRYPT](AES_DECRYPT.md)
# Funzione AES\$1ENCRYPT
La funzione AES\$1ENCRYPT viene utilizzata per crittografare i dati utilizzando l'algoritmo Advanced Encryption Standard (AES).
## Sintassi
```
aes_encrypt(expr, key[, mode[, padding[, iv[, aad]]]])
```
## Argomenti
*expr*
Il valore binario da crittografare.
*key*
La passphrase da utilizzare per crittografare i dati.
Sono supportate lunghezze di chiave di 16, 24 e 32 bit.
*modalità*
Speciifica quale modalità di cifratura a blocchi deve essere utilizzata per crittografare i messaggi.
Modalità valide: ECB (Electronic CodeBook), GCM (Galois/Counter Mode), CBC (Cipher-Block Chaining).
*imbottitura*
Specifica come riempire i messaggi la cui lunghezza non è un multiplo della dimensione del blocco.
Valori validi: PKCS, NONE, DEFAULT.
Il padding DEFAULT indica PKCS (Public Key Cryptography Standards) per ECB, NONE per GCM e PKCS per CBC.
Le combinazioni supportate di (*mode*, *padding*) sono ('ECB', 'PKCS'), ('GCM', 'NONE') e ('CBC', 'PKCS').
*iv*
Vettore di inizializzazione opzionale (IV). Supportato solo per le modalità CBC e GCM.
Valori validi: 12 byte di lunghezza per GCM e 16 byte per CBC.
*aad*
Dati autenticati aggiuntivi opzionali (AAD). Supportato solo per la modalità GCM. Può essere qualsiasi input in formato libero e deve essere fornito sia per la crittografia che per la decrittografia.
## Tipo restituito
La funzione AES\$1ENCRYPT restituisce un valore crittografato di *expr* utilizzando AES in una determinata modalità con il padding specificato.
## Esempi
L'esempio seguente mostra come utilizzare la funzione Spark SQL AES\$1ENCRYPT per crittografare in modo sicuro una stringa di dati (in questo caso, la parola «Spark») utilizzando una chiave di crittografia specificata. Il testo cifrato risultante viene quindi codificato in Base64 per semplificare l'archiviazione o la trasmissione.
```
SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop'));
4A5jOAh9FNGwoMeuJukfllrLdHEZxA2DyuSQAWz77dfn
```
L'esempio seguente mostra come utilizzare la funzione Spark SQL AES\$1ENCRYPT per crittografare in modo sicuro una stringa di dati (in questo caso, la parola «Spark») utilizzando una chiave di crittografia specificata. Il testo cifrato risultante viene quindi rappresentato in formato esadecimale, che può essere utile per attività come l'archiviazione, la trasmissione o il debug dei dati.
```
SELECT hex(aes_encrypt('Spark', '0000111122223333'));
83F16B2AA704794132802D248E6BFD4E380078182D1544813898AC97E709B28A94
```
L'esempio seguente mostra come utilizzare la funzione Spark SQL AES\$1ENCRYPT per crittografare in modo sicuro una stringa di dati (in questo caso, «Spark SQL») utilizzando una chiave di crittografia, una modalità di crittografia e una modalità di riempimento specificate. Il testo cifrato risultante viene quindi codificato in Base64 per semplificare l'archiviazione o la trasmissione.
```
SELECT base64(aes_encrypt('Spark SQL', '1234567890abcdef', 'ECB', 'PKCS'));
3lmwu+Mw0H3fi5NDvcu9lg==
```
# Funzione AES\$1DECRYPT
La funzione AES\$1DECRYPT viene utilizzata per decrittografare i dati utilizzando l'algoritmo Advanced Encryption Standard (AES).
## Sintassi
```
aes_decrypt(expr, key[, mode[, padding[, aad]]])
```
## Argomenti
*expr*
Il valore binario da decifrare.
*key*
La passphrase da utilizzare per decrittografare i dati.
La passphrase deve corrispondere alla chiave utilizzata originariamente per produrre il valore crittografato ed essere lunga 16, 24 o 32 byte.
*modalità*
Speciifica quale modalità di cifratura a blocchi deve essere utilizzata per decrittografare i messaggi.
Modalità valide: ECB, GCM, CBC.
*imbottitura*
Specifica come riempire i messaggi la cui lunghezza non è un multiplo della dimensione del blocco.
Valori validi: PKCS, NONE, DEFAULT.
Il padding DEFAULT indica PKCS per ECB, NONE per GCM e PKCS per CBC.
*- aad*
Dati autenticati aggiuntivi opzionali (AAD). Supportato solo per la modalità GCM. Può essere qualsiasi input in formato libero e deve essere fornito sia per la crittografia che per la decrittografia.
## Tipo restituito
Restituisce un valore decrittografato di *expr* utilizzando AES in modalità con padding.
## Esempi
L'esempio seguente mostra come utilizzare la funzione Spark SQL AES\$1ENCRYPT per crittografare in modo sicuro una stringa di dati (in questo caso, la parola «Spark») utilizzando una chiave di crittografia specificata. Il testo cifrato risultante viene quindi codificato in Base64 per semplificare l'archiviazione o la trasmissione.
```
SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop'));
4A5jOAh9FNGwoMeuJukfllrLdHEZxA2DyuSQAWz77dfn
```
L'esempio seguente dimostra come utilizzare la funzione Spark SQL AES\$1DECRYPT per decrittografare dati precedentemente crittografati e codificati in Base64. Il processo di decrittografia richiede la chiave e i parametri di crittografia corretti (modalità di crittografia e modalità padding) per ripristinare correttamente i dati di testo in chiaro originali.
```
SELECT aes_decrypt(unbase64('3lmwu+Mw0H3fi5NDvcu9lg=='), '1234567890abcdef', 'ECB', 'PKCS');
Spark SQL
```
# Funzioni hash
Una funzione hash è una funzione matematica che converte un valore di input numerico in un altro valore.
AWS Clean Rooms Spark SQL supporta le seguenti funzioni hash:
**Topics**
+ [MD5 funzione](s_MD5.md)
+ [Funzione SHA](s_SHA.md)
+ [SHA1 funzione](s_SHA1.md)
+ [SHA2 funzione](s_SHA2.md)
+ [HASH64 funzione xx](xxhash64.md)
# MD5 funzione
Utilizza la funzione hash MD5 crittografica per convertire una stringa di lunghezza variabile in una stringa di 32 caratteri che è una rappresentazione testuale del valore esadecimale di un checksum a 128 bit.
## Sintassi
```
MD5(string)
```
## Argomenti
*stringa*
Una stringa di lunghezza variabile.
## Tipo restituito
La MD5 funzione restituisce una stringa di 32 caratteri che è una rappresentazione testuale del valore esadecimale di un checksum a 128 bit.
## Esempi
L'esempio seguente mostra il valore a 128 bit per la stringa "AWS Clean Rooms":
```
select md5('AWS Clean Rooms');
md5
----------------------------------
f7415e33f972c03abd4f3fed36748f7a
(1 row)
```
# Funzione SHA
Sinonimo di funzione. SHA1
Consultare [SHA1 funzione](s_SHA1.md).
# SHA1 funzione
La SHA1 funzione utilizza la funzione hash SHA1 crittografica per convertire una stringa di lunghezza variabile in una stringa di 40 caratteri che è una rappresentazione testuale del valore esadecimale di un checksum a 160 bit.
## Sintassi
SHA1 è sinonimo di. [Funzione SHA](s_SHA.md)
```
SHA1(string)
```
## Argomenti
*stringa*
Una stringa di lunghezza variabile.
## Tipo restituito
La SHA1 funzione restituisce una stringa di 40 caratteri che è una rappresentazione testuale del valore esadecimale di un checksum a 160 bit.
## Esempio
L'esempio seguente restituisce il valore a 160 bit per la parola 'AWS Clean Rooms':
```
select sha1('AWS Clean Rooms');
```
# SHA2 funzione
La SHA2 funzione utilizza la funzione hash SHA2 crittografica per convertire una stringa di lunghezza variabile in una stringa di caratteri. La stringa di caratteri è una rappresentazione testuale del valore esadecimale del checksum con il numero specificato di bit.
## Sintassi
```
SHA2(string, bits)
```
## Argomenti
*stringa*
Una stringa di lunghezza variabile.
*integer*
Numero di bit nelle funzioni hash. I valori validi sono 0 (uguale a 256), 224, 256, 384 e 512.
## Tipo restituito
La SHA2 funzione restituisce una stringa di caratteri che è una rappresentazione testuale del valore esadecimale del checksum o una stringa vuota se il numero di bit non è valido.
## Esempio
L'esempio seguente restituisce il valore a 256 bit per la parola 'AWS Clean Rooms':
```
select sha2('AWS Clean Rooms', 256);
```
# HASH64 funzione xx
La funzione xxhash64 restituisce un valore hash a 64 bit degli argomenti.
La funzione xxhash64 () è una funzione hash non crittografica progettata per essere veloce ed efficiente. Viene spesso utilizzata nelle applicazioni di elaborazione e archiviazione dei dati, in cui è necessario un identificatore univoco per un dato, ma non è necessario mantenere segreto il contenuto esatto dei dati.
Nel contesto di una query SQL, la funzione xxhash64 () può essere utilizzata per vari scopi, ad esempio:
+ Generazione di un identificatore univoco per una riga in una tabella
+ Partizionamento dei dati in base a un valore hash
+ Implementazione di strategie personalizzate di indicizzazione o distribuzione dei dati
Il caso d'uso specifico dipenderebbe dai requisiti dell'applicazione e dai dati da elaborare.
## Sintassi
```
xxhash64(expr1, expr2, ...)
```
## Argomenti
*espr (1)*
Un'espressione di qualsiasi tipo.
*expr 2*
Un'espressione di qualsiasi tipo.
## Valori restituiti
Restituisce un valore hash a 64 bit degli argomenti (BIGINT). L'hash seed è 42.
## Esempio
L'esempio seguente genera un valore hash a 64 bit (5602566077635097486) in base all'input fornito. Il primo argomento è un valore di stringa, in questo caso la parola «Spark». Il secondo argomento è un array contenente il valore intero singolo 123. Il terzo argomento è un valore intero che rappresenta il seme della funzione hash.
```
SELECT xxhash64('Spark', array(123), 2);
5602566077635097486
```
# Funzioni Hyperloglog
Le funzioni HyperLogLog (HLL) di SQL forniscono un modo per stimare in modo efficiente il numero di elementi unici (cardinalità) in un set di dati di grandi dimensioni, anche quando l'insieme effettivo di elementi unici non è archiviato.
I principali vantaggi dell'utilizzo delle funzioni HLL sono:
+ **Efficienza della memoria**: gli schizzi HLL richiedono molta meno memoria rispetto all'archiviazione dell'intero set di elementi unici, il che li rende adatti a set di dati di grandi dimensioni.
+ **Calcolo distribuito**: gli schizzi HLL possono essere combinati su più fonti di dati o nodi di elaborazione, consentendo una stima efficiente e distribuita del conteggio.
+ **Risultati approssimativi**: HLL fornisce una stima approssimativa del conteggio univoca, con un compromesso regolabile tra precisione e utilizzo della memoria (tramite il parametro di precisione).
Queste funzioni sono particolarmente utili in scenari in cui è necessario stimare il numero di elementi unici, ad esempio nelle applicazioni di analisi, data warehousing e elaborazione di flussi in tempo reale.
AWS Clean Rooms supporta le seguenti funzioni HLL.
**Topics**
+ [funzione HLL\$1SKETCH\$1AGG](HLL_SKETCH_AGG.md)
+ [Funzione HLL\$1SKETCH\$1ESTIMATE](HLL_SKETCH_ESTIMATE.md)
+ [Funzione HLL\$1UNION](HLL_UNION.md)
+ [Funzione HLL\$1UNION\$1AGG](HLL_UNION_AGG.md)
# funzione HLL\$1SKETCH\$1AGG
La funzione di aggregazione HLL\$1SKETCH\$1AGG crea uno sketch HLL dai valori nella colonna specificata. Restituisce un tipo di dati HLLSKETCH che incapsula i valori delle espressioni di input.
La funzione di aggregazione HLL\$1SKETCH\$1AGG funziona con qualsiasi tipo di dati e ignora i valori NULL.
Quando non ci sono righe in una tabella o tutte le righe sono NULL, lo schizzo risultante non ha coppie indice-valore come `{"version":1,"logm":15,"sparse":{"indices":[],"values":[]}}`.
## Sintassi
```
HLL_SKETCH_AGG (aggregate_expression[, lgConfigK ] )
```
## Argomento
*aggregate\$1expression*
Qualsiasi espressione di tipo INT, BIGINT, STRING o BINARY rispetto alla quale verrà eseguito un conteggio univoco. Tutti i `NULL` valori vengono ignorati.
*LGConfigK*
Una costante INT opzionale compresa tra 4 e 21 inclusi con 12 di default. Il log-base-2 di K, dove K è il numero di bucket o slot per lo schizzo.
## Tipo restituito
La funzione HLL\$1SKETCH\$1AGG restituisce un buffer BINARY non NULL contenente lo sketch calcolato poiché consuma e aggrega tutti i valori di input nel gruppo di aggregazione. HyperLogLog
## Esempi
Gli esempi seguenti utilizzano l'algoritmo HyperLogLog (HLL) per stimare il numero distinto di valori nella colonna. `col` La `hll_sketch_agg(col, 12)` funzione aggrega i valori nella colonna col, creando uno schizzo HLL con una precisione di 12. La `hll_sketch_estimate()` funzione viene quindi utilizzata per stimare il numero distinto di valori in base allo schizzo HLL generato. Il risultato finale della query è 3, che rappresenta il conteggio distinto stimato di valori nella `col` colonna. In questo caso, i valori distinti sono 1, 2 e 3.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
L'esempio seguente utilizza anche l'algoritmo HLL per stimare il numero distinto di valori nella `col` colonna, ma non specifica un valore di precisione per lo sketch HLL. In questo caso, utilizza la precisione predefinita di 14. La `hll_sketch_agg(col)` funzione prende i valori nella `col` colonna e crea uno schizzo HyperLogLog (HLL), che è una struttura di dati compatta che può essere utilizzata per stimare il numero distinto di elementi. La `hll_sketch_estimate(hll_sketch_agg(col))` funzione utilizza lo schizzo HLL creato nel passaggio precedente e calcola una stima del numero distinto di valori nella colonna. `col` Il risultato finale della query è 3, che rappresenta il numero distinto stimato di valori nella colonna. `col` In questo caso, i valori distinti sono 1, 2 e 3.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
# Funzione HLL\$1SKETCH\$1ESTIMATE
La funzione HLL\$1SKETCH\$1ESTIMATE esegue uno schizzo HLL e stima il numero di elementi unici rappresentati dallo schizzo. Utilizza l'algoritmo HyperLogLog (HLL) per contare un'approssimazione probabilistica del numero di valori univoci in una determinata colonna, utilizzando una rappresentazione binaria nota come buffer di sketch generata in precedenza dalla funzione HLL\$1SKETCH\$1AGG e restituendo il risultato come un numero intero grande.
L'algoritmo di disegno HLL fornisce un modo efficiente per stimare il numero di elementi unici, anche per set di dati di grandi dimensioni, senza dover memorizzare l'intero set di valori univoci.
Le `hll_union_agg` funzioni `hll_union` and possono anche combinare gli schizzi utilizzando e unendo questi buffer come input.
## Sintassi
```
HLL_SKETCH_ESTIMATE (hllsketch_expression)
```
## Argomento
*hllsketch\$1expression*
Un'`BINARY`espressione contenente uno schizzo generato da HLL\$1SKETCH\$1AGG
## Tipo restituito
La funzione HLL\$1SKETCH\$1ESTIMATE restituisce un valore BIGINT che è il conteggio distinto approssimativo rappresentato dallo schizzo di input.
## Esempi
Gli esempi seguenti utilizzano l'algoritmo di disegno HyperLogLog (HLL) per stimare la cardinalità (conteggio univoco) dei valori nella colonna. `col` La `hll_sketch_agg(col, 12)` funzione prende la `col` colonna e crea uno schizzo HLL con una precisione di 12 bit. Lo sketch HLL è una struttura di dati approssimativa in grado di stimare in modo efficiente il numero di elementi unici in un set. La `hll_sketch_estimate()` funzione prende lo schizzo HLL creato da `hll_sketch_agg` e stima la cardinalità (conteggio univoco) dei valori rappresentati dallo schizzo. `FROM VALUES (1), (1), (2), (2), (3) tab(col);`Genera un set di dati di test con 5 righe, in cui la `col` colonna contiene i valori 1, 1, 2, 2 e 3. Il risultato di questa query è il conteggio univoco stimato dei valori nella `col` colonna, che è 3.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
La differenza tra l'esempio seguente e quello precedente è che il parametro di precisione (12 bit) non è specificato nella chiamata di `hll_sketch_agg` funzione. In questo caso, viene utilizzata la precisione predefinita di 14 bit, che può fornire una stima più accurata del conteggio unico rispetto all'esempio precedente che utilizzava 12 bit di precisione.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
# Funzione HLL\$1UNION
La funzione HLL\$1UNION combina due schizzi HLL in un unico schizzo unificato. Utilizza l'algoritmo HyperLogLog (HLL) per combinare due schizzi in un unico schizzo. Le query possono utilizzare i buffer risultanti per calcolare conteggi univoci approssimativi sotto forma di numeri interi lunghi con la funzione. `hll_sketch_estimate`
## Sintassi
```
HLL_UNION (( expr1, expr2 [, allowDifferentLgConfigK ] ))
```
## Argomento
*Exprn*
Un'`BINARY`espressione contenente uno schizzo generato da HLL\$1SKETCH\$1AGG.
*allowDifferentLgConfigK*
Un'espressione BOOLEAN opzionale che controlla se consentire l'unione di due schizzi con valori LGConfigK diversi. Il valore predefinito è `false`.
## Tipo restituito
La funzione HLL\$1UNION restituisce un buffer BINARY contenente lo HyperLogLog schizzo calcolato come risultato della combinazione delle espressioni di input. Quando il `allowDifferentLgConfigK` parametro è`true`, lo schizzo del risultato utilizza il più piccolo dei due valori forniti. `lgConfigK`
## Esempi
Gli esempi seguenti utilizzano l'algoritmo di disegno HyperLogLog (HLL) per stimare il conteggio univoco dei valori su due colonne `col1` e `col2` in un set di dati.
La `hll_sketch_agg(col1)` funzione crea uno schizzo HLL per i valori univoci nella colonna. `col1`
La `hll_sketch_agg(col2)` funzione crea uno schizzo HLL per i valori univoci nella colonna col2.
La `hll_union(...)` funzione combina i due schizzi HLL creati nei passaggi 1 e 2 in un unico schizzo HLL unificato.
La `hll_sketch_estimate(...)` funzione utilizza lo schizzo HLL combinato e stima il conteggio univoco dei valori per entrambi e. `col1` `col2`
La `FROM VALUES` clausola genera un set di dati di test con 5 righe, dove `col1` contiene i valori 1, 1, 2, 2 e 3 e `col2` contiene i valori 4, 4, 5, 5 e 6.
Il risultato di questa query è il conteggio unico stimato di valori per entrambi `col1` e`col2`, che è 6. L'algoritmo di disegno HLL offre un modo efficiente per stimare il numero di elementi unici, anche per set di dati di grandi dimensioni, senza dover memorizzare l'intero set di valori univoci. In questo esempio, la `hll_union` funzione viene utilizzata per combinare gli schizzi HLL delle due colonne, il che consente di stimare il conteggio univoco per l'intero set di dati, anziché solo per ogni colonna singolarmente.
```
SELECT hll_sketch_estimate(
hll_union(
hll_sketch_agg(col1),
hll_sketch_agg(col2)))
FROM VALUES
(1, 4),
(1, 4),
(2, 5),
(2, 5),
(3, 6) AS tab(col1, col2);
6
```
La differenza tra l'esempio seguente e quello precedente è che il parametro di precisione (12 bit) non è specificato nella chiamata alla funzione. `hll_sketch_agg` In questo caso, viene utilizzata la precisione predefinita di 14 bit, che può fornire una stima più accurata del conteggio unico rispetto all'esempio precedente che utilizzava 12 bit di precisione.
```
SELECT hll_sketch_estimate(
hll_union(
hll_sketch_agg(col1, 14),
hll_sketch_agg(col2, 14)))
FROM VALUES
(1, 4),
(1, 4),
(2, 5),
(2, 5),
(3, 6) AS tab(col1, col2);
```
# Funzione HLL\$1UNION\$1AGG
La funzione HLL\$1UNION\$1AGG combina più schizzi HLL in un unico schizzo unificato. Utilizza l'algoritmo HyperLogLog (HLL) per combinare un gruppo di schizzi in uno solo. Le query possono utilizzare i buffer risultanti per calcolare conteggi univoci approssimativi con la funzione. `hll_sketch_estimate`
## Sintassi
```
HLL_UNION_AGG ( expr [, allowDifferentLgConfigK ] )
```
## Argomento
*expr*
Un'`BINARY`espressione contenente uno schizzo generato da HLL\$1SKETCH\$1AGG.
*allowDifferentLgConfigK*
Un'espressione BOOLEAN opzionale che controlla se consentire l'unione di due schizzi con valori LGConfigK diversi. Il valore predefinito è `false`.
## Tipo restituito
La funzione HLL\$1UNION\$1AGG restituisce un buffer BINARY contenente lo HyperLogLog sketch calcolato come risultato della combinazione delle espressioni di input dello stesso gruppo. Quando il `allowDifferentLgConfigK` parametro è, lo schizzo del risultato utilizza il più `true` piccolo dei due valori forniti. `lgConfigK`
## Esempi
I seguenti esempi utilizzano l'algoritmo di sketch HyperLogLog (HLL) per stimare il conteggio univoco dei valori su più schizzi HLL.
Il primo esempio stima il conteggio univoco dei valori in un set di dati.
```
SELECT hll_sketch_estimate(hll_union_agg(sketch, true))
FROM (SELECT hll_sketch_agg(col) as sketch
FROM VALUES (1) AS tab(col)
UNION ALL
SELECT hll_sketch_agg(col, 20) as sketch
FROM VALUES (1) AS tab(col));
1
```
L'interrogazione interna crea due sketch HLL:
+ La prima istruzione SELECT crea uno schizzo a partire da un singolo valore di 1.
+ La seconda istruzione SELECT crea uno schizzo a partire da un altro valore singolo di 1, ma con una precisione di 20.
La query esterna utilizza la funzione HLL\$1UNION\$1AGG per combinare i due schizzi in un unico schizzo. Quindi applica la funzione HLL\$1SKETCH\$1ESTIMATE a questo sketch combinato per stimare il conteggio univoco dei valori.
Il risultato di questa query è il conteggio univoco stimato dei valori nella colonna, che è. `col` `1` Ciò significa che i due valori di input pari a 1 sono considerati unici, anche se hanno lo stesso valore.
Il secondo esempio include un parametro di precisione diverso per la funzione HLL\$1UNION\$1AGG. In questo caso, entrambi gli schizzi HLL vengono creati con una precisione di 14 bit, il che consente di combinarli con successo utilizzando il parametro. `hll_union_agg` `true`
```
SELECT hll_sketch_estimate(hll_union_agg(sketch, true))
FROM (SELECT hll_sketch_agg(col, 14) as sketch
FROM VALUES (1) AS tab(col)
UNION ALL
SELECT hll_sketch_agg(col, 14) as sketch
FROM VALUES (1) AS tab(col));
1
```
Il risultato finale della query è il conteggio univoco stimato, che anche in questo caso è. `1` Ciò significa che i due valori di input pari a 1 sono considerati unici, anche se hanno lo stesso valore.
# Funzioni JSON
Quando è necessario memorizzare un insieme relativamente piccolo di coppie chiave-valore, è possibile risparmiare spazio memorizzando i dati nel formato JSON. Poiché le stringhe JSON possono essere memorizzate in una singola colonna, l'utilizzo di JSON potrebbe essere più efficiente rispetto all'archiviazione dei dati in formato tabulare.
**Example**
Ad esempio, supponiamo di avere una tabella sparsa, in cui è necessario disporre di molte colonne per rappresentare appieno tutti gli attributi possibili. Tuttavia, la maggior parte dei valori delle colonne sono NULL per una determinata riga o colonna. Utilizzando JSON per l'archiviazione, potresti essere in grado di archiviare i dati di una riga in coppie chiave-valore in una singola stringa JSON ed eliminare le colonne della tabella scarsamente popolate.
Inoltre, è possibile modificare facilmente le stringhe JSON per memorizzare coppie chiavi:valore aggiuntive senza dover aggiungere colonne a una tabella.
È consigliabile usare un JSON con parsimonia. JSON non è una buona scelta per archiviare set di dati di grandi dimensioni perché, archiviando dati diversi in una singola colonna, JSON non utilizza l'architettura dell'archivio di colonne. AWS Clean Rooms
JSON utilizza stringhe di testo con codifica UTF-8, pertanto le stringhe JSON possono essere memorizzate come tipi di dati CHAR o VARCHAR. Utilizzare VARCHAR se le stringhe includono caratteri multibyte.
Le stringhe JSON devono essere formattate in modo corretto con JSON, in base alle seguenti regole:
+ Il JSON di livello radice può essere un oggetto JSON o un array JSON. Un oggetto JSON è un insieme non ordinato di coppie di chiave:valore separate da virgole racchiuse da parentesi graffe.
Ad esempio, `{"one":1, "two":2} `
+ Un array JSON è un insieme ordinato di valori separati da virgola racchiusi tra parentesi.
Un esempio è quanto segue: `["first", {"one":1}, "second", 3, null] `
+ Gli array JSON utilizzano un indice basato su zero; il primo elemento di un array è in posizione 0. In una coppia chiave:valore JSON, la chiave è una stringa racchiusa tra virgolette doppie.
+ Un valore JSON può essere uno dei seguenti:
+ Oggetto JSON
+ Array JSON
+ Stringa tra virgolette doppie
+ Numero (intero e a virgola mobile)
+ Booleano
+ Null
+ Gli oggetti vuoti e gli array vuoti sono valori JSON validi.
+ I campi JSON fanno distinzione tra maiuscole e minuscole.
+ Lo spazio bianco tra gli elementi strutturali JSON (ad esempio `{ }, [ ]`) viene ignorato.
**Topics**
+ [Funzione GET\$1JSON\$1OBJECT](GET_JSON_OBJECT.md)
+ [Funzione TO\$1JSON](TO_JSON.md)
# Funzione GET\$1JSON\$1OBJECT
La funzione GET\$1JSON\$1OBJECT estrae un oggetto json da. `path`
## Sintassi
```
get_json_object(json_txt, path)
```
## Argomenti
*json\$1txt*
Un'espressione STRING contenente JSON ben formato.
*path*
Un valore letterale STRING con un'espressione di percorso JSON ben formata.
## Valori restituiti
Restituisce una STRING.
Viene restituito un valore NULL se l'oggetto non può essere trovato.
## Esempio
L'esempio seguente estrae un valore da un oggetto JSON. Il primo argomento è una stringa JSON che rappresenta un oggetto semplice con una singola coppia chiave-valore. Il secondo argomento è un'espressione di percorso JSON. Il `$` simbolo rappresenta la radice dell'oggetto JSON e la `.a` parte specifica che vogliamo estrarre il valore associato alla chiave "»`a`. L'output della funzione è '`b`', che è il valore associato al tasto "`a`" nell'oggetto JSON di input.
```
SELECT get_json_object('{"a":"b"}', '$.a');
b
```
# Funzione TO\$1JSON
La funzione TO\$1JSON converte un'espressione di input in una rappresentazione di stringa JSON. La funzione gestisce la conversione di diversi tipi di dati (come numeri, stringhe e valori booleani) nelle rappresentazioni JSON corrispondenti.
La funzione TO\$1JSON è utile quando è necessario convertire dati strutturati (come righe di database o oggetti JSON) in un formato più portatile e autodescrittivo come JSON. Ciò può essere particolarmente utile quando è necessario interagire con altri sistemi o servizi che prevedono dati in formato JSON.
## Sintassi
```
to_json(expr[, options])
```
## Argomenti
*expr*
L'espressione di input che desideri convertire in una stringa JSON. Può essere un valore, una colonna o qualsiasi altra espressione SQL valida.
*options*
Un set opzionale di opzioni di configurazione che possono essere utilizzate per personalizzare il processo di conversione JSON. Queste opzioni possono includere cose come la gestione di valori nulli, la rappresentazione di valori numerici e il trattamento di caratteri speciali.
## Valori restituiti
Restituisce una stringa JSON con un determinato valore di struttura
## Esempi
L'esempio seguente converte una struttura denominata (un tipo di dati strutturati) in una stringa JSON. Il primo argomento `(named_struct('a', 1, 'b', 2)` () è l'espressione di input che viene passata alla `to_json()` funzione. Crea una struttura denominata con due campi: «a» con un valore di 1 e «b» con un valore di 2. La funzione to\$1json () prende la struttura denominata come argomento e la converte in una rappresentazione di stringa JSON. L'output è`{"a":1,"b":2}`, che è una stringa JSON valida che rappresentava la struttura denominata.
```
SELECT to_json(named_struct('a', 1, 'b', 2));
{"a":1,"b":2}
```
L'esempio seguente converte una struttura denominata che contiene un valore di timestamp in una stringa JSON, con un formato timestamp personalizzato. Il primo argomento (`named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd'))`) crea una struttura denominata con un singolo campo 'time' che contiene il valore del timestamp. Il secondo argomento (`map('timestampFormat', 'dd/MM/yyyy')`) crea una mappa (dizionario chiave-valore) con una singola coppia chiave-valore, dove la chiave è 'timestampFormat' e il valore è ''. dd/MM/yyyy'. This map is used to specify the desired format for the timestamp value when converting it to JSON. The to\$1json() function converts the named struct into a JSON string. The second argument, the map, is used to customize the timestamp format to 'dd/MM/yyyy L'output è `{"time":"26/08/2015"}` una stringa JSON con un singolo campo 'time' che contiene il valore del timestamp nel formato '' desiderato. dd/MM/yyyy
```
SELECT to_json(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
{"time":"26/08/2015"}
```
# 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)
```
# Funzioni scalari
Questa sezione descrive le funzioni scalari supportate in Spark SQL. AWS Clean Rooms Una funzione scalare è una funzione che accetta uno o più valori come input e restituisce un singolo valore come output. Le funzioni scalari operano su singole righe o elementi e producono un unico risultato per ogni input.
Le funzioni scalari, come SIZE, sono diverse dagli altri tipi di funzioni SQL, come le funzioni aggregate (count, sum, avg) e le funzioni di generazione di tabelle (explode, flatten). Questi altri tipi di funzioni operano su più righe o generano più righe, mentre le funzioni scalari funzionano su singole righe o elementi.
**Topics**
+ [Funzione SIZE](size.md)
# Funzione SIZE
La funzione SIZE accetta una matrice, una mappa o una stringa esistente come argomento e restituisce un singolo valore che rappresenta la dimensione o la lunghezza di quella struttura di dati. Non crea una nuova struttura di dati. Viene utilizzato per interrogare e analizzare le proprietà delle strutture di dati esistenti, anziché per crearne di nuove.
Questa funzione è utile per determinare il numero di elementi in un array o la lunghezza di una stringa. Può essere particolarmente utile quando si lavora con matrici e altre strutture di dati in SQL, perché consente di ottenere informazioni sulla dimensione o sulla cardinalità dei dati.
## Sintassi
```
size(expr)
```
## Argomenti
*expr*
Un'espressione ARRAY, MAP o STRING.
## Tipo restituito
La funzione SIZE restituisce un valore INTEGER.
## Esempio
In questo esempio, la funzione SIZE viene applicata all'array `['b', 'd', 'c', 'a']` e restituisce il valore`4`, che è il numero di elementi nell'array.
```
SELECT size(array('b', 'd', 'c', 'a'));
4
```
In questo esempio, la funzione SIZE viene applicata alla mappa `{'a': 1, 'b': 2}` e restituisce il valore`2`, che è il numero di coppie chiave-valore nella mappa.
```
SELECT size(map('a', 1, 'b', 2));
2
```
In questo esempio, la funzione SIZE viene applicata alla stringa `'hello world'` e restituisce il valore`11`, che è il numero di caratteri nella stringa.
```
SELECT size('hello world');
11
```
# Funzioni stringa
Le funzioni di stringa elaborano e manipolano stringhe di caratteri o espressioni che valutano le stringhe di caratteri. Quando l'argomento *stringa* in queste funzioni è un valore letterale, deve essere racchiuso tra virgolette singole. I tipi di dati supportati includono CHAR e VARCHAR.
La seguente sezione fornisce i nomi della funzione, la sintassi e le descrizioni per le funzioni supportate. Tutti gli offset in stringhe sono basati su uno.
**Topics**
+ [\$1\$1 (Concatenamento) Operatore](concat_op.md)
+ [Funzione BTRIM](BTRIM.md)
+ [Funzione CONCAT](CONCAT.md)
+ [Funzione FORMAT\$1STRING](FORMAT_STRING.md)
+ [Funzioni LEFT e RIGHT](LEFT.md)
+ [Funzione LENGTH](LENGTH.md)
+ [Funzione LOWER](LOWER.md)
+ [Funzioni LPAD e RPAD](LPAD.md)
+ [Funzione LTRIM](LTRIM.md)
+ [Funzione POSITION](POSITION.md)
+ [Funzione REGEXP\$1COUNT](REGEXP_COUNT.md)
+ [Funzione REGEXP\$1INSTR](REGEXP_INSTR.md)
+ [Funzione REGEXP\$1REPLACE](REGEXP_REPLACE.md)
+ [Funzione REGEXP\$1SUBSTR](REGEXP_SUBSTR.md)
+ [Funzione REPEAT](REPEAT.md)
+ [Funzione REPLACE](REPLACE.md)
+ [Funzione REVERSE](REVERSE.md)
+ [Funzione RTRIM](RTRIM.md)
+ [Funzione SPLIT](split.md)
+ [Funzione SPLIT\$1PART](SPLIT_PART.md)
+ [Funzione SUBSTRING](SUBSTRING.md)
+ [Funzione TRANSLATE](TRANSLATE.md)
+ [Funzione TRIM](TRIM.md)
+ [Funzione UPPER](UPPER.md)
+ [Funzione UUID](UUID.md)
# \$1\$1 (Concatenamento) Operatore
Concatena due espressioni su entrambi i lati del simbolo \$1\$1 e restituisce l'espressione concatenata.
L'operatore di concatentazione è simile a. [Funzione CONCAT](CONCAT.md)
**Nota**
Sia per la funzione CONCAT sia per l'operatore di concatenazione, se una o entrambe le espressioni sono nulle, il risultato della concatenazione è nullo.
## Sintassi
```
expression1 || expression2
```
## Argomenti
*expression1*, *expression2*
Entrambi gli argomenti possono essere stringhe di caratteri o espressioni a lunghezza fissa o a lunghezza variabile.
## Tipo restituito
L'operatore \$1\$1 restituisce una stringa. Il tipo di stringa è lo stesso degli argomenti di input.
## Esempio
L'esempio seguente concatena i campi FIRSTNAME e LASTNAME dalla tabella USERS:
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
Per concatenare le colonne che potrebbero contenere valori null, utilizzare l'espressione [Funzioni NVL e COALESCE](NVL_function.md). Il seguente esempio utilizza NVL per restituire uno 0 ogni volta che si incontra NULL.
```
select venuename || ' seats ' || nvl(venueseats, 0)
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 10;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
Hilton Hotel seats 0
Luxor Hotel seats 0
Mandalay Bay Hotel seats 0
Mirage Hotel seats 0
New York New York seats 0
```
# Funzione BTRIM
La funzione BTRIM riduce una stringa rimuovendo spazi vuoti iniziali e finali o rimuovendo i caratteri iniziali e finali che corrispondono a una stringa specificata facoltativa.
## Sintassi
```
BTRIM(string [, trim_chars ] )
```
## Argomenti
*stringa*
La stringa VARCHAR di input da ridurre.
*trim\$1chars*
La stringa VARCHAR contenente i caratteri da abbinare.
## Tipo restituito
La funzione BTRIM restituisce una stringa VARCHAR.
## Esempi
L'esempio seguente riduce gli spazi vuoti iniziali e finali dalla stringa `' abc '`:
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L'esempio seguente rimuove le stringhe `'xyz'` iniziali e finali dalla stringa `'xyzaxyzbxyzcxyz'`. Le occorrenze iniziali e finali di `'xyz'` vengono rimosse, ma le occorrenze interne alla stringa non vengono rimosse.
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
L'esempio seguente rimuove le parti iniziale e finale dalla stringa `'setuphistorycassettes'` che corrispondono a uno qualsiasi dei caratteri nell'elenco `'tes'` *trim\$1chars*. Qualsiasi carattere `t`, `e` o `s` che si verifica prima di un altro carattere che non è nell'elenco *trim\$1chars* all'inizio o alla fine della stringa di input viene rimosso.
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# Funzione CONCAT
La funzione CONCAT concatena due espressioni e restituisce l'espressione risultante. Per concatenare più di due espressioni, utilizzare le funzioni CONCAT nidificate. L'operatore di concatenazione (`||`) tra due espressioni produce gli stessi risultati della funzione CONCAT.
**Nota**
Sia per la funzione CONCAT sia per l'operatore di concatenazione, se una o entrambe le espressioni sono nulle, il risultato della concatenazione è nullo.
## Sintassi
```
CONCAT ( expression1, expression2 )
```
## Argomenti
*expression1*, *expression2*
Entrambi gli argomenti possono essere una stringa di caratteri a lunghezza fissa, una stringa di caratteri a lunghezza variabile, un'espressione binaria o un'espressione che valuta uno di questi input.
## Tipo restituito
CONCAT restituisce un'espressione. Il tipo di dati dell'espressione è lo stesso tipo degli argomenti di input.
Se le espressioni di input sono di tipi diversi, AWS Clean Rooms prova a digitare implicitamente genera una delle espressioni. Se non è possibile eseguire il cast di valori, viene restituito il valore nullo.
## Esempi
L'esempio seguente concatena due letterali di caratteri:
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
La seguente query, utilizzando l'operatore `||` invece di CONCAT, produce lo stesso risultato:
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
Nell'esempio seguente vengono utilizzate due funzioni CONCAT per concatenare tre stringhe di caratteri:
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Per concatenare le colonne che potrebbero contenere valori null, utilizzare la [Funzioni NVL e COALESCE](NVL_function.md). Il seguente esempio utilizza NVL per restituire uno 0 ogni volta che si incontra NULL.
```
select concat(venuename, concat(' seats ', nvl(venueseats, 0))) as seating
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
La query seguente concatena i valori CITY e STATE dalla tabella VENUE:
```
select concat(venuecity, venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
La seguente query utilizza funzioni CONCAT nidificate. La query concatena i valori CITY e STATE dalla tabella VENUE ma delimita la stringa risultante con una virgola e uno spazio:
```
select concat(concat(venuecity,', '),venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
# Funzione FORMAT\$1STRING
La funzione FORMAT\$1STRING crea una stringa formattata sostituendo i segnaposto in una stringa modello con gli argomenti forniti. Restituisce una stringa formattata da stringhe di formato in stile printf.
La funzione FORMAT\$1STRING funziona sostituendo i segnaposto nella stringa del modello con i valori corrispondenti passati come argomenti. Questo tipo di formattazione delle stringhe può essere utile quando è necessario creare dinamicamente stringhe che includono una combinazione di testo statico e dati dinamici, ad esempio quando si generano messaggi di output, report o altri tipi di testo informativo. La funzione FORMAT\$1STRING fornisce un modo conciso e leggibile per creare questi tipi di stringhe formattate, semplificando la manutenzione e l'aggiornamento del codice che genera l'output.
## Sintassi
```
format_string(strfmt, obj, ...)
```
## Argomenti
*strfmt*
Un'espressione STRING.
*obj*
Una STRINGA o un'espressione numerica.
## Tipo restituito
FORMAT\$1STRING restituisce una STRING.
## Esempio
L'esempio seguente contiene una stringa modello che contiene due segnaposto: `%d` per un valore decimale (intero) e per un valore di stringa. `%s` Il `%d` segnaposto viene sostituito con il valore decimale (intero) () e il segnaposto %s viene sostituito con il valore di stringa (`100`). `"days"` L'output è una stringa modello con i segnaposto sostituiti dagli argomenti forniti:. `"Hello World 100 days"`
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# Funzioni LEFT e RIGHT
Queste funzioni restituiscono il numero specificato di caratteri più a sinistra o più a destra da una stringa di caratteri.
Il numero si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli.
## Sintassi
```
LEFT ( string, integer )
RIGHT ( string, integer )
```
## Argomenti
*stringa*
Qualsiasi stringa di caratteri o espressione che valuti una stringa di caratteri.
*integer*
Un integer positivo.
## Tipo restituito
LEFT e RIGHT restituiscono una stringa VARCHAR.
## Esempio
L'esempio seguente restituisce i 5 caratteri più a sinistra e i 5 caratteri più a destra dei nomi di eventi con un valore compreso tra 1000 e 1005: IDs
```
select eventid, eventname,
left(eventname,5) as left_5,
right(eventname,5) as right_5
from event
where eventid between 1000 and 1005
order by 1;
eventid | eventname | left_5 | right_5
--------+----------------+--------+---------
1000 | Gypsy | Gypsy | Gypsy
1001 | Chicago | Chica | icago
1002 | The King and I | The K | and I
1003 | Pal Joey | Pal J | Joey
1004 | Grease | Greas | rease
1005 | Chicago | Chica | icago
(6 rows)
```
# Funzione LENGTH
# Funzione LOWER
Converte una stringa in minuscolo. LOWER supporta caratteri multibyte UTF-8, fino a un massimo di quattro byte per carattere.
## Sintassi
```
LOWER(string)
```
## Argomento
*stringa*
Il parametro di input è una stringa VARCHAR (o qualsiasi altro tipo di dati, ad esempio CHAR, che può essere convertito implicitamente in VARCHAR).
## Tipo restituito
La funzione LOWER restituisce una stringa di caratteri che appartiene allo stesso tipo di dati della stringa di input.
## Esempi
L'esempio seguente converte il campo CATNAME in lettere minuscole:
```
select catname, lower(catname) from category order by 1,2;
catname | lower
----------+-----------
Classical | classical
Jazz | jazz
MLB | mlb
MLS | mls
Musicals | musicals
NBA | nba
NFL | nfl
NHL | nhl
Opera | opera
Plays | plays
Pop | pop
(11 rows)
```
# Funzioni LPAD e RPAD
Queste funzioni antepongono o aggiungono caratteri a una stringa, in base a una lunghezza specificata.
## Sintassi
```
LPAD (string1, length, [ string2 ])
```
```
RPAD (string1, length, [ string2 ])
```
## Argomenti
*string1*
Una stringa di caratteri o un'espressione che valuta una stringa di caratteri, come il nome di una colonna di caratteri.
*length*
Un integer che definisce la lunghezza del risultato della funzione. La lunghezza di una stringa si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Se *string1* è più lunga della lunghezza specificata, viene troncata (a destra). Se *lunghezza* è un numero negativo, il risultato della funzione è una stringa vuota.
*string2*
Uno o più caratteri anteposti o aggiunti a *string1*. Questo argomento è facoltativo; se non è specificato, gli spazi vengono usati.
## Tipo restituito
Queste funzioni restituiscono un tipo di dati VARCHAR.
## Esempi
Troncare un insieme specificato di nomi di eventi a 20 caratteri e anteporre ai nomi più brevi gli spazi:
```
select lpad(eventname,20) from event
where eventid between 1 and 5 order by 1;
lpad
--------------------
Salome
Il Trovatore
Boris Godunov
Gotterdammerung
La Cenerentola (Cind
(5 rows)
```
Troncare lo stesso insieme specificato di nomi di eventi a 20 caratteri ma aggiungere ai nomi più brevi `0123456789`.
```
select rpad(eventname,20,'0123456789') from event
where eventid between 1 and 5 order by 1;
rpad
--------------------
Boris Godunov0123456
Gotterdammerung01234
Il Trovatore01234567
La Cenerentola (Cind
Salome01234567890123
(5 rows)
```
# Funzione LTRIM
Taglia i caratteri dall'inizio di una stringa. Rimuove la stringa più lunga contenente solo i caratteri nell'elenco dei caratteri di taglio. Il taglio è completo quando un carattere di taglio non appare nella stringa di input.
## Sintassi
```
LTRIM( string [, trim_chars] )
```
## Argomenti
*stringa*
Una stringa, una colonna, un'espressione o una stringa letterale da tagliare.
*trim\$1chars*
Una colonna o un'espressione di stringhe o un valore letterale di stringa che rappresenta i caratteri da tagliare dall'inizio della *stringa*. Se non specificato, viene utilizzato uno spazio come carattere di taglio.
## Tipo restituito
La funzione LTRIM restituisce una stringa di caratteri che appartiene allo stesso tipo di dati della *stringa* di input (CHAR o VARCHAR).
## Esempi
L'esempio seguente taglia l'anno dalla colonna `listime`. I caratteri di taglio nel valore letterale di stringa `'2008-'` indicano i caratteri da tagliare da sinistra. Se si utilizzano i caratteri di taglio `'028-'`, si ottiene lo stesso risultato.
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
LTRIM rimuove tutti i caratteri in *trim\$1chars* se questi si trovano all'inizio di *stringa*. L'esempio seguente riduce i caratteri "C", "D" e "G" quando si trovano all'inizio di VENUENAME che è una colonna VARCHAR.
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
L'esempio seguente utilizza il carattere di taglio `2` che viene recuperato dalla colonna `venueid`.
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
L'esempio seguente non taglia alcun carattere perché prima del carattere di taglio `'0'` è presente un `2`.
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
L'esempio seguente utilizza il carattere di taglio dello spazio predefinito e taglia i due spazi dall'inizio della stringa.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# Funzione POSITION
Restituisce la posizione della sottostringa specificata all'interno di una stringa.
## Sintassi
```
POSITION(substring IN string )
```
## Argomenti
*sottostringa*
La sottostringa da cercare all'interno della *stringa*.
*stringa*
La stringa o colonna da ricercare.
## Tipo restituito
La funzione POSITION restituisce un integer corrispondente alla posizione della sottostringa (basata su uno, non su zero). La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli.
## Note per l'utilizzo
POSITION restituisce 0 se la sottostringa non si trova all'interno della stringa:
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## Esempi
L'esempio seguente mostra la posizione della stringa `fish` all'interno della parola `dogfish`:
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
L'esempio seguente restituisce il numero di transazioni di vendita con una COMMISSION superiore a 999,00 dalla tabella SALES:
```
select distinct position('.' in commission), count (position('.' in commission))
from sales where position('.' in commission) > 4 group by position('.' in commission)
order by 1,2;
position | count
---------+-------
5 | 629
(1 row)
```
# Funzione REGEXP\$1COUNT
Cerca una stringa per un modello di espressione regolare e restituisce un integer che indica il numero di volte in cui il modello si verifica nella stringa. Se non viene trovata alcuna corrispondenza, la funzione restituisce 0.
## Sintassi
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## Argomenti
*source\$1string*
Un'espressione di stringa, come ad esempio un nome di colonna, da cercare.
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
*posizione*
Un integer positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore di default è 1. Se *posizione* è inferiore a 1, la ricerca inizia con il primo carattere di *source\$1string*. Se *posizione* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è 0.
*parameters*
Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole.
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole.
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE).
## Tipo restituito
Numero intero
## Esempio
L'esempio seguente conta il numero di volte in cui si verifica una sequenza di tre lettere.
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
L'esempio seguente conta il numero di volte in cui il nome di dominio di livello superiore è `org` oppure `edu`.
```
SELECT email, regexp_count(email,'@[^.]*\\.(org|edu)')FROM users
ORDER BY userid LIMIT 4;
email | regexp_count
-----------------------------------------------+--------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1
Suspendisse.tristique@nonnisiAenean.edu | 1
amet.faucibus.ut@condimentumegetvolutpat.ca | 0
sed@lacusUtnec.ca | 0
```
Nell'esempio seguente vengono conteggiate le ricorrenze della stringa `FOX` utilizzando una corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene contato il numero di ricorrenze di tali parole, con la corrispondenza tra maiuscole e minuscole.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione specifica in PCRE. In questo esempio viene contato il numero di ricorrenze di tali parole, ma differisce dall'esempio precedente in quanto utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# Funzione REGEXP\$1INSTR
Cerca una stringa per un modello di espressione regolare e restituisce un integer che indica la posizione iniziale o finale della sottostringa corrispondente. Se non viene trovata alcuna corrispondenza, la funzione restituisce 0. REGEXP\$1INSTR è simile alla funzione [POSITION](POSITION.md), ma consente di cercare una stringa per un modello di espressione regolare.
## Sintassi
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Argomenti
*source\$1string*
Un'espressione di stringa, come ad esempio un nome di colonna, da cercare.
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
*posizione*
Un integer positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore di default è 1. Se *posizione* è inferiore a 1, la ricerca inizia con il primo carattere di *source\$1string*. Se *posizione* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è 0.
*occorrenza*
Un integer positivo che indica quale occorrenza del modello utilizzare. REGEXP\$1INSTR salta le prime corrispondenze *occorrenza* -1. Il valore di default è 1. Se *occorrenza* è inferiore a 1 oppure maggiore rispetto al numero di caratteri in *source\$1string*, la ricerca viene ignorata e il risultato è 0.
*option*
Un valore che indica se restituire la posizione del primo carattere della corrispondenza (`0`) o la posizione del primo carattere dopo la fine della corrispondenza (`1`). Un valore diverso da zero equivale a 1. Il valore predefinito è 0.
*parameters*
Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole.
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole.
+ e: estrarre una sottostringa usando una sottoespressione.
Se *modello* include una sottoespressione, REGEXP\$1INSTR corrisponde a una sottostringa che utilizza la prima sottoespressione in *modello*. REGEXP\$1INSTR considera solo la prima sottoespressione; le sottoespressioni aggiuntive vengono ignorate. Se il modello non ha una sottoespressione, REGEXP\$1INSTR ignora il parametro "e".
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE).
## Tipo restituito
Numero intero
## Esempio
Nell'esempio seguente viene cercato il carattere `@` che inizia un nome di dominio e restituisce la posizione iniziale della prima corrispondenza.
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
Nell'esempio seguente vengono cercate le varianti della parola `Center` e viene restituita la posizione iniziale della prima corrispondenza.
```
SELECT venuename, regexp_instr(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE regexp_instr(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
venuename | regexp_instr
-----------------------+--------------
The Home Depot Center | 16
Izod Center | 6
Wachovia Center | 10
Air Canada Centre | 12
```
Nell'esempio seguente viene trovata la posizione iniziale della prima ricorrenza della stringa `FOX` utilizzando una logica di associazione senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene trovata la posizione iniziale della seconda parola di questo tipo.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene trovata la posizione iniziale della seconda parola, ma differisce dall'esempio precedente in quanto utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
regexp_instr
--------------
15
```
# Funzione REGEXP\$1REPLACE
Cerca una stringa per un modello di espressione regolare e sostituisce ogni occorrenza del modello con la stringa specificata. REGEXP\$1REPLACE è simile a [Funzione REPLACE](REPLACE.md), ma consente di cercare una stringa per un modello di espressione regolare.
REGEXP\$1REPLACE è simile a [Funzione TRANSLATE](TRANSLATE.md) e a [Funzione REPLACE](REPLACE.md), ad eccezione del fatto che TRANSLATE esegue più sostituzioni a carattere singolo e REPLACE sostituisce un'intera stringa con un'altra stringa, mentre REGEXP\$1REPLACE consente di cercare una stringa per un modello di espressione regolare.
## Sintassi
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## Argomenti
*source\$1string*
Un'espressione di stringa, come ad esempio un nome di colonna, da cercare.
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
*replace\$1string*
Un'espressione di stringa, ad esempio un nome di colonna, che sostituirà ogni occorrenza del modello. L'impostazione predefinita è una stringa vuota ( "" ).
*posizione*
Un integer positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore di default è 1. Se *posizione* è inferiore a 1, la ricerca inizia con il primo carattere di *source\$1string*. Se *posizione* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è *source\$1string*.
*parameters*
Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole.
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole.
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE).
## Tipo restituito
VARCHAR
Se *modello* oppure *replace\$1string* è NULL, il risultato è NULL.
## Esempio
L'esempio seguente elimina `@` e il nome di dominio dagli indirizzi email.
```
SELECT email, regexp_replace(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+----------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut
sed@lacusUtnec.ca | sed
```
Nell'esempio seguente sono sostituiti i nomi di dominio degli indirizzi e-mail con questo valore: `internal.company.com`.
```
SELECT email, regexp_replace(email, '@.*\\.[[:alpha:]]{2,3}',
'@internal.company.com') FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+--------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com
sed@lacusUtnec.ca | sed@internal.company.com
```
Nell'esempio seguente vengono sostituite tutte le ricorrenze della stringa `FOX` con il valore `quick brown fox` utilizzando una corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'i');
regexp_replace
---------------------
the quick brown fox
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene sostituita ogni ricorrenza di tale parola con il valore `[hidden]`.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene sostituita ogni ricorrenza di tale parola con il valore `[hidden]`, ma differisce dall'esempio precedente in quanto utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# Funzione REGEXP\$1SUBSTR
Restituisce i caratteri da una stringa cercando un modello di espressione regolare. REGEXP\$1SUBSTR è simile alla funzione [Funzione SUBSTRING](SUBSTRING.md) ma consente di cercare una stringa per un modello di espressione regolare. Se la funzione non riesce a far corrispondere l'espressione regolare ad alcun carattere della stringa, restituisce una stringa vuota.
## Sintassi
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argomenti
*source\$1string*
Un'espressione della stringa da ricercare.
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
*posizione*
Un integer positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore di default è 1. Se *posizione* è inferiore a 1, la ricerca inizia con il primo carattere di *source\$1string*. Se *posizione* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è una stringa vuota ("").
*occorrenza*
Un integer positivo che indica quale occorrenza del modello utilizzare. REGEXP\$1SUBSTR salta le prime corrispondenze *occorrenza* -1. Il valore di default è 1. Se *occorrenza* è inferiore a 1 oppure maggiore rispetto al numero di caratteri in *source\$1string*, la ricerca viene ignorata e il risultato è NULL.
*parameters*
Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole.
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole.
+ e: estrarre una sottostringa usando una sottoespressione.
Se *modello* include una sottoespressione, REGEXP\$1SUBSTR corrisponde a una sottostringa che utilizza la prima sottoespressione in *modello*. Un'espressione secondaria è un'espressione all'interno del modello racchiusa tra parentesi. Ad esempio, per il modello `'This is a (\\w+)'` corrisponde alla prima espressione con la stringa `'This is a '` seguita da una parola. Invece di restituire un *modello*, REGEXP\$1SUBSTR con il parametro `e` restituisce solo la stringa all'interno dell'espressione secondaria.
REGEXP\$1SUBSTR considera solo la prima sottoespressione; le sottoespressioni aggiuntive vengono ignorate. Se il modello non ha una sottoespressione, REGEXP\$1SUBSTR ignora il parametro "e".
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE).
## Tipo restituito
VARCHAR
## Esempio
L'esempio seguente restituisce la porzione di un indirizzo email tra il carattere @ e l'estensione del dominio.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
Nell'esempio seguente viene restituita la porzione dell'input corrispondente alla prima ricorrenza della stringa `FOX` utilizzando una corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
L'istruzione di esempio seguente restituisce la prima parte dell'input che inizia con lettere minuscole. Dal punto di vista funzionale è identica alla medesima istruzione SELECT senza il parametro `c`.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene restituita la parte dell'input corrispondente alla seconda parola di questo tipo.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene restituita la parte di input corrispondente alla seconda parola, ma differisce dall'esempio precedente in quanto si utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
L'esempio seguente utilizza un'espressione secondaria per trovare la seconda stringa che corrisponde al modello `'this is a (\\w+)'` utilizzando la corrispondenza senza distinzione tra maiuscole e minuscole. Restituisce l'espressione secondaria tra parentesi.
```
select regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# Funzione REPEAT
Ripete una stringa il numero specificato di volte. Se il parametro di input è numerico, REPEAT lo considera come una stringa.
## Sintassi
```
REPEAT(string, integer)
```
## Argomenti
*stringa*
Il primo parametro di input è la stringa da ripetere.
*integer*
Il secondo parametro è un integer che indica il numero di volte in cui ripetere la stringa.
## Tipo restituito
La funzione REPEAT restituisce una stringa.
## Esempi
L'esempio seguente ripete il valore della colonna CATID nella tabella CATEGORY tre volte:
```
select catid, repeat(catid,3)
from category
order by 1,2;
catid | repeat
-------+--------
1 | 111
2 | 222
3 | 333
4 | 444
5 | 555
6 | 666
7 | 777
8 | 888
9 | 999
10 | 101010
11 | 111111
(11 rows)
```
# Funzione REPLACE
Sostituisce tutte le occorrenze di un insieme di caratteri all'interno di una stringa esistente con altri caratteri specificati.
REPLACE è simile a [Funzione TRANSLATE](TRANSLATE.md) e a [Funzione REGEXP\$1REPLACE](REGEXP_REPLACE.md), ad eccezione del fatto che TRANSLATE esegue più sostituzioni a carattere singolo e REGEXP\$1REPLACE consente di cercare una stringa per un modello di espressione regolare, mentre REPLACE sostituisce un'intera stringa con un'altra stringa.
## Sintassi
```
REPLACE(string1, old_chars, new_chars)
```
## Argomenti
*stringa*
La stringa CHAR o VARCHAR da cercare in ricerca
*old\$1chars*
La stringa CHAR o VARCHAR da sostituire.
*new\$1chars*
Nuova stringa CHAR o VARCHAR che sostituisce la *old\$1string*.
## Tipo restituito
VARCHAR
Se *old\$1chars* oppure *new\$1chars* è NULL, il risultato è NULL.
## Esempi
L'esempio seguente converte la stringa `Shows` in `Theatre` nel campo CATGROUP:
```
select catid, catgroup,
replace(catgroup, 'Shows', 'Theatre')
from category
order by 1,2,3;
catid | catgroup | replace
-------+----------+----------
1 | Sports | Sports
2 | Sports | Sports
3 | Sports | Sports
4 | Sports | Sports
5 | Sports | Sports
6 | Shows | Theatre
7 | Shows | Theatre
8 | Shows | Theatre
9 | Concerts | Concerts
10 | Concerts | Concerts
11 | Concerts | Concerts
(11 rows)
```
# Funzione REVERSE
La funzione REVERSE funziona su una stringa e restituisce i caratteri in ordine inverso. Ad esempio, `reverse('abcde')` restituisce `edcba`. Questa funzione funziona su tipi di dati numerici e di date, così come su tipi di dati di carattere; tuttavia, nella maggior parte dei casi ha un valore pratico per le stringhe di caratteri.
## Sintassi
```
REVERSE ( expression )
```
## Argomento
*espressione*
Un'espressione con un carattere, una data, un timestamp o un tipo di dati numerici che rappresenta la destinazione dell'inversione di caratteri. Tutte le espressioni sono implicitamente convertite in stringhe di caratteri a lunghezza variabile. Gli spazi finali in stringhe di caratteri a larghezza fissa vengono ignorati.
## Tipo restituito
REVERSE restituisce una VARCHAR.
## Esempi
Selezionare cinque nomi di città distinti e i corrispondenti nomi invertiti dalla tabella USERS:
```
select distinct city as cityname, reverse(cityname)
from users order by city limit 5;
cityname | reverse
---------+----------
Aberdeen | needrebA
Abilene | enelibA
Ada | adA
Agat | tagA
Agawam | mawagA
(5 rows)
```
Seleziona cinque vendite IDs e il corrispondente IDs cast invertito come stringhe di caratteri:
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# Funzione RTRIM
La funzione RTRIM riduce un insieme specificato di caratteri dalla fine di una stringa. Rimuove la stringa più lunga contenente solo i caratteri nell'elenco dei caratteri di taglio. Il taglio è completo quando un carattere di taglio non appare nella stringa di input.
## Sintassi
```
RTRIM( string, trim_chars )
```
## Argomenti
*stringa*
Una stringa, una colonna, un'espressione o una stringa letterale da tagliare.
*trim\$1chars*
Una colonna o un'espressione di stringa o un valore letterale di stringa che rappresenta i caratteri da tagliare dall'inizio della *stringa*. Se non specificato, viene utilizzato uno spazio come carattere di taglio.
## Tipo restituito
Una stringa che è lo stesso tipo di dati dell'argomento *stringa*.
## Esempio
L'esempio seguente riduce gli spazi vuoti iniziali e finali dalla stringa `' abc '`:
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L'esempio seguente rimuove le stringhe `'xyz'` iniziali dalla stringa `'xyzaxyzbxyzcxyz'`. Le occorrenze finali di `'xyz'` vengono rimosse, ma le occorrenze interne alla stringa non vengono rimosse.
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
L'esempio seguente rimuove le parti finali dalla stringa `'setuphistorycassettes'` che corrispondono a uno qualsiasi dei caratteri nell'elenco `'tes'` *trim\$1chars*. Qualsiasi carattere `t`, `e` o `s` che si verifica prima di un altro carattere che non è nell'elenco *trim\$1chars* alla fine della stringa di input viene rimosso.
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
L'esempio seguente riduce i caratteri "Parco"dalla fine di VENUENAME laddove presente:
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
Si noti che RTRIM rimuove tutti i caratteri in `P`, `a` , `r` oppure `k` quando appaiono alla fine di un VENUENAME.
# Funzione SPLIT
La funzione SPLIT consente di estrarre sottostringhe da una stringa più grande e utilizzarle come matrice. La funzione SPLIT è utile quando è necessario suddividere una stringa in singoli componenti in base a un delimitatore o uno schema specifico.
## Sintassi
```
split(str, regex, limit)
```
## Argomenti
*str*
Un'espressione stringa da dividere.
*regex*
Una stringa che rappresenta un'espressione regolare. La stringa *regex* deve essere un'espressione regolare Java.
*limite*
Un'espressione intera che controlla il numero di volte in cui viene applicata l'espressione *regolare.*
+ *limit > 0: la lunghezza dell'array risultante non sarà superiore al limite e l'ultima voce dell'array risultante conterrà tutti gli input oltre l'ultima espressione regolare corrispondente.*
+ limit <= 0: l'*espressione regolare* verrà applicata il maggior numero di volte possibile e l'array risultante può essere di qualsiasi dimensione.
## Tipo restituito
La funzione SPLIT restituisce un ARRAY.
Se`limit > 0`: la lunghezza dell'array risultante non sarà superiore al limite e l'ultima voce dell'array risultante conterrà tutti gli input oltre l'ultima espressione regolare corrispondente.
If`limit <= 0`: regex verrà applicato il maggior numero di volte possibile e l'array risultante può essere di qualsiasi dimensione.
## Esempio
In questo esempio, la funzione SPLIT divide la stringa di input `'oneAtwoBthreeC'` ovunque incontri i caratteri `'A'` o `'C'` (come specificato dal modello di espressione regolare). `'B'` `'[ABC]'` L'output risultante è una matrice di quattro elementi:`"one"`, `"two"``"three"`, e una stringa vuota. `""`
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# Funzione SPLIT\$1PART
Divide una stringa sul delimitatore specificato e restituisce la parte nella posizione specificata.
## Sintassi
```
SPLIT_PART(string, delimiter, position)
```
## Argomenti
*stringa*
Una stringa, una colonna, un'espressione o una stringa letterale da dividere. La stringa può essere CHAR o VARCHAR.
*delimiter*
La stringa del delimitatore che indica le sezioni della *stringa* di input.
Se *delimiter* è un letterale, racchiuderlo tra virgolette singole.
*posizione*
Posizione della porzione di *stringa* da restituire (contando da 1). Deve essere un integer superiore a 0. Se *posizione* è maggiore del numero di porzioni di stringa, SPLIT\$1PART restituisce una stringa vuota. Se il *delimitatore* non si trova nella *stringa*, il valore restituito contiene i contenuti della parte specificata, che possono essere l'intera *stringa* o un valore vuoto.
## Tipo restituito
Una stringa CHAR o VARCHAR, uguale al parametro di *stringa*.
## Esempi
L'esempio seguente divide una stringa letterale in parti utilizzando il delimitatore `$` e restituisce la seconda parte.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
L'esempio seguente divide una stringa letterale in parti utilizzando il delimitatore `$`. Restituisce una stringa vuota perché la parte `4` non viene trovata.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
L'esempio seguente divide una stringa letterale in parti utilizzando il delimitatore `#`. Restituisce l'intera stringa, che è la prima parte, perché il delimitatore non è stato trovato.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
L'esempio seguente divide il campo timestamp LISTTIME in componenti anno, mese e data.
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
L'esempio seguente seleziona il campo timestamp LISTTIME e lo divide sul carattere `'-'` per ottenere il mese (la seconda parte della stringa LISTTIME), quindi conta il numero di voci per ogni mese:
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# Funzione SUBSTRING
Restituisce il sottoinsieme di una stringa basata su una posizione iniziale specificata.
Se l'input è una stringa di carattere, la posizione iniziale e il numero di caratteri estratti si basano sui caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Se l'input è un'espressione binaria, la posizione iniziale e la sottostringa estratta sono basate su byte. Non è possibile specificare una lunghezza negativa, ma è possibile specificare una posizione di partenza negativa.
## Sintassi
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argomenti
*stringa di caratteri*
La stringa da cercare. I tipi di dati non carattere sono trattati come una stringa.
*start\$1position*
La posizione all'interno della stringa per iniziare l'estrazione, a partire da 1. La *start\$1position* si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Questo numero può essere negativo.
*caratteri numerici*
Il numero di caratteri da estrarre (la lunghezza della sottostringa). Il *numbecharacters* si basa sul numero di caratteri, non sui byte, in modo che i caratteri multibyte vengano contati come caratteri singoli. Questo numero non può essere negativo.
*start\$1byte*
La posizione all'interno dell'espressione binaria per iniziare l'estrazione, a partire da 1. Questo numero può essere negativo.
*numero di byte*
Il numero di byte da estrarre, ovvero, la lunghezza della sottostringa. Questo numero non può essere negativo.
## Tipo restituito
VARCHAR
## Note di utilizzo per le stringhe di caratteri
L'esempio seguente restituisce una stringa di quattro caratteri che inizia con il sesto carattere.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*Se *start\$1position* \$1 *numbecharacters* supera la lunghezza della stringa, SUBSTRING restituisce una *sottostringa* a partire da start\$1position fino alla fine della stringa.* Per esempio:
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
Se la `start_position` è negativa o pari a 0, la funzione SUBSTRING restituisce una sottostringa che inizia dal primo carattere di stringa con una lunghezza di `start_position` \$1 `numbecharacters` -1. Ad esempio:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Se `start_position` \$1 `numbecharacters` -1 è inferiore o pari a zero, SUBSTRING restituisce una stringa vuota. Ad esempio:
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## Esempi
L'esempio seguente restituisce il mese dalla stringa LISTTIME nella tabella LISTING:
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
L'esempio seguente è lo stesso di sopra, ma utilizza l'opzione FROM...FOR:
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
Non è possibile utilizzare SUBSTRING per estrarre in modo prevedibile il prefisso di una stringa che potrebbe contenere caratteri multibyte poiché è necessario specificare la lunghezza di una stringa multibyte in base al numero di byte, non al numero di caratteri. Per estrarre il segmento iniziale di una stringa in base alla lunghezza in byte, è possibile eseguire il CAST della stringa come VARCHAR(*byte\$1length*) per troncare la stringa, laddove *byte\$1length* è la lunghezza necessaria. L'esempio seguente estrae i primi 5 byte dalla stringa `'Fourscore and seven'`.
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
L'esempio seguente restituisce il nome `Ana` che appare dopo l'ultimo spazio nella stringa di input `Silva, Ana`.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# Funzione TRANSLATE
Per una data espressione, sostituisce tutte le occorrenze di caratteri specificati con sostituti specificati. I caratteri esistenti sono mappati per i caratteri sostitutivi in base alla loro posizione negli argomenti *characters\$1to\$1replace* e *characters\$1to\$1substitute*. Se vengono specificati più caratteri nell'argomento *characters\$1to\$1replace* rispetto all'argomento *characters\$1to\$1substitute*, i caratteri extra dall'argomento *characters\$1to\$1replace* vengono omessi nel valore di restituzione.
TRANSLATE è simile a [Funzione REPLACE](REPLACE.md) e a [Funzione REGEXP\$1REPLACE](REGEXP_REPLACE.md), ad eccezione del fatto che REPLACE sostituisce un'intera stringa con un'altra stringa e REGEXP\$1REPLACE consente di cercare una stringa per un modello di espressione regolare, mentre TRANSLATE realizza più sostituzioni a carattere singolo.
Se qualsiasi argomento è null, la restituzione è NULL.
## Sintassi
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## Argomenti
*espressione*
L'espressione da tradurre.
*characters\$1to\$1replace*
Una stringa contenente i caratteri da sostituire.
*characters\$1to\$1substitute*
Una stringa contenente i caratteri da sostituire.
## Tipo restituito
VARCHAR
## Esempi
L'esempio seguente sostituisce diversi caratteri in una stringa:
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
L'esempio seguente sostituisce il simbolo at (@) con un punto per tutti i valori in una colonna:
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
L'esempio seguente sostituisce gli spazi con caratteri di sottolineatura ed elimina i punti per tutti i valori in una colonna:
```
select city, translate(city, ' .', '_') from users
where city like 'Sain%' or city like 'St%'
group by city
order by city;
city translate
--------------+------------------
Saint Albans Saint_Albans
Saint Cloud Saint_Cloud
Saint Joseph Saint_Joseph
Saint Louis Saint_Louis
Saint Paul Saint_Paul
St. George St_George
St. Marys St_Marys
St. Petersburg St_Petersburg
Stafford Stafford
Stamford Stamford
Stanton Stanton
Starkville Starkville
Statesboro Statesboro
Staunton Staunton
Steubenville Steubenville
Stevens Point Stevens_Point
Stillwater Stillwater
Stockton Stockton
Sturgis Sturgis
```
# Funzione TRIM
Riduce una stringa rimuovendo spazi vuoti iniziali e finali o rimuovendo i caratteri iniziali e finali che corrispondono a una stringa specificata facoltativa.
## Sintassi
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## Argomenti
*trim\$1chars*
(Facoltativo) I caratteri da ridurre dalla stringa. Se questo parametro viene omesso, gli spazi vuoti vengono ridotti.
*stringa*
La stringa da ridurre.
## Tipo restituito
La funzione TRIM restituisce una stringa VARCHAR o CHAR. Se si utilizza la funzione TRIM con un comando SQL, converte implicitamente i risultati in VARCHAR. AWS Clean Rooms Se si utilizza la funzione TRIM nell'elenco SELECT per una funzione SQL, AWS Clean Rooms non converte implicitamente i risultati e potrebbe essere necessario eseguire una conversione esplicita per evitare un errore di mancata corrispondenza del tipo di dati. Vedi la [Funzione CAST](CAST_function.md) funzione per informazioni sulle conversioni esplicite.
## Esempio
L'esempio seguente riduce gli spazi vuoti iniziali e finali dalla stringa `' abc '`:
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
Nell'esempio seguente vengono rimosse le virgolette doppie che circondano la stringa `"dog"`:
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
TRIM rimuove tutti i caratteri in *trim\$1chars* se questi si trovano all'inizio di *stringa*. L'esempio seguente riduce i caratteri "C", "D" e "G" quando si trovano all'inizio di VENUENAME che è una colonna VARCHAR.
```
select venueid, venuename, trim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
# Funzione UPPER
Converte una stringa in maiuscolo. UPPER supporta caratteri multibyte UTF-8, fino a un massimo di quattro byte per carattere.
## Sintassi
```
UPPER(string)
```
## Argomenti
*stringa*
Il parametro di input è una stringa VARCHAR (o qualsiasi altro tipo di dati, ad esempio CHAR, che può essere convertito implicitamente in VARCHAR).
## Tipo restituito
La funzione UPPER restituisce una stringa di caratteri che appartiene allo stesso tipo di dati della stringa di input.
## Esempi
L'esempio seguente converte il campo CATNAME in lettere maiuscole:
```
select catname, upper(catname) from category order by 1,2;
catname | upper
----------+-----------
Classical | CLASSICAL
Jazz | JAZZ
MLB | MLB
MLS | MLS
Musicals | MUSICALS
NBA | NBA
NFL | NFL
NHL | NHL
Opera | OPERA
Plays | PLAYS
Pop | POP
(11 rows)
```
# Funzione UUID
La funzione UUID genera un identificatore univoco universale (UUID).
UUIDs sono identificatori univoci globali che vengono comunemente utilizzati per fornire identificatori univoci per vari scopi, come:
+ Identificazione dei record del database o di altre entità di dati.
+ Generazione di nomi o chiavi univoci per file, directory o altre risorse.
+ Monitoraggio e correlazione dei dati tra sistemi distribuiti.
+ Fornitura di identificatori univoci per pacchetti di rete, componenti software o altre risorse digitali.
La funzione UUID genera un valore UUID unico con una probabilità molto elevata, anche su sistemi distribuiti e per lunghi periodi di tempo. UUIDs vengono generalmente generati utilizzando una combinazione del timestamp corrente, dell'indirizzo di rete del computer e di altri dati casuali o pseudo-casuali, garantendo che è altamente improbabile che ogni UUID generato entri in conflitto con altri UUID.
Nel contesto di una query SQL, la funzione UUID può essere utilizzata per generare identificatori univoci per nuovi record da inserire in un database o per fornire chiavi univoche per il partizionamento dei dati, l'indicizzazione o altri scopi in cui è richiesto un identificatore univoco.
**Nota**
La funzione UUID non è deterministica.
## Sintassi
```
uuid()
```
## Argomenti
La funzione UUID non accetta argomenti.
## Tipo restituito
UUID restituisce una stringa di identificazione univoca universale (UUID). Il valore viene restituito come stringa UUID canonica di 36 caratteri.
## Esempio
L'esempio seguente genera un identificatore univoco universale (UUID). L'output è una stringa di 36 caratteri che rappresenta un identificatore univoco universale.
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```
# Funzioni relative alla privacy
AWS Clean Rooms fornisce funzioni per aiutarti a rispettare la conformità relativa alla privacy per le seguenti specifiche.
+ **Global Privacy Platform (GPP)**: una specifica dell'Interactive Advertising Bureau (IAB) che stabilisce un framework globale e standardizzato per la privacy e l'uso dei dati online. [Per ulteriori informazioni sulle specifiche tecniche del GPP, consulta la documentazione della Global Privacy Platform su. GitHub](https://github.com/InteractiveAdvertisingBureau/Global-Privacy-Platform)
+ **Transparency and Consent Framework (TCF)** — Un componente chiave del GPP, lanciato nel 2020, che fornisce un quadro tecnico standardizzato per aiutare le aziende a rispettare le normative sulla privacy come il Regolamento generale sulla protezione dei dati (GDPR) dell'UE. Il TCF consente ai clienti di concedere o negare il consenso alla raccolta e al trattamento dei dati. [Per ulteriori informazioni sulle specifiche tecniche di TCF, consulta la documentazione TCF su. GitHub](https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework/tree/master/TCFv2)
**Topics**
+ [funzione consent\$1gpp\$1v1\$1decode](consent_gpp_v1_decode.md)
+ [funzione consent\$1tcf\$1v2\$1decode](consent_tcf_v2_decode.md)
# funzione consent\$1gpp\$1v1\$1decode
La `consent_gpp_v1_decode` funzione viene utilizzata per decodificare i dati di consenso della Global Privacy Platform (GPP) v1. Prende come input la stringa di consenso codificata e restituisce i dati di consenso decodificati, che includono informazioni sulle preferenze di privacy e sulle scelte di consenso dell'utente. Questa funzione è utile quando si lavora con dati che includono informazioni sul consenso GPP v1, in quanto consente di accedere e analizzare i dati di consenso in un formato strutturato.
## Sintassi
```
consent_gpp_v1_decode(gpp_string)
```
## Argomenti
*gpp\$1string*
La stringa di consenso GPP v1 codificata.
## Valori restituiti
Il dizionario restituito include le seguenti coppie chiave-valore:
+ `version`: La versione della specifica GPP utilizzata (attualmente 1).
+ `cmpId`: L'ID della piattaforma di gestione del consenso (CMP) che ha codificato la stringa di consenso.
+ `cmpVersion`: la versione della CMP che ha codificato la stringa di consenso.
+ `consentScreen`: L'ID della schermata nell'interfaccia utente CMP in cui l'utente ha fornito il consenso.
+ `consentLanguage`: Il codice della lingua delle informazioni sul consenso.
+ `vendorListVersion`: la versione dell'elenco dei fornitori utilizzata.
+ `publisherCountryCode`: il codice del paese dell'editore.
+ `purposeConsent`: un elenco di numeri interi che rappresentano gli scopi per i quali l'utente ha acconsentito.
+ `purposeLegitimateInterest`: Un elenco di scopi IDs per i quali l'interesse legittimo dell'utente è stato comunicato in modo trasparente.
+ `specialFeatureOptIns`: Un elenco di numeri interi che rappresentano le funzioni speciali che l'utente ha scelto.
+ `vendorConsent`: un elenco di fornitori a IDs cui l'utente ha acconsentito.
+ `vendorLegitimateInterest`: Un elenco di fornitori IDs per i quali l'interesse legittimo dell'utente è stato comunicato in modo trasparente.
## Esempio
L'esempio seguente utilizza un singolo argomento, che è la stringa di consenso codificata. Restituisce un dizionario contenente i dati di consenso decodificati, comprese le informazioni sulle preferenze di privacy dell'utente, le scelte di consenso e altri metadati.
```
SELECT * FROM consent_gpp_v1_decode('ABCDEFGHIJK');
```
La struttura di base dei dati di consenso restituiti include informazioni sulla versione della stringa di consenso, i dettagli della CMP (Consent Management Platform), il consenso dell'utente e le scelte di interesse legittimo per scopi e fornitori diversi e altri metadati.
```
{
"version": 1,
"cmpId": 12,
"cmpVersion": 34,
"consentScreen": 5,
"consentLanguage": "en",
"vendorListVersion": 89,
"publisherCountryCode": "US",
"purposeConsent": [1],
"purposeLegitimateInterests": [1],
"specialFeatureOptins": [1],
"vendorConsent": [1],
"vendorLegitimateInterests": [1]}
}
```
# funzione consent\$1tcf\$1v2\$1decode
La `consent_tcf_v2_decode` funzione viene utilizzata per decodificare i dati di consenso di Transparency and Consent Framework (TCF) v2. Prende come input la stringa di consenso codificata e restituisce i dati di consenso decodificati, che includono informazioni sulle preferenze di privacy e sulle scelte di consenso dell'utente. Questa funzione è utile quando si lavora con dati che includono informazioni sul consenso TCF v2, in quanto consente di accedere e analizzare i dati di consenso in un formato strutturato.
## Sintassi
```
consent_tcf_v2_decode(tcf_string)
```
## Argomenti
*tcf\$1string*
La stringa di consenso TCF v2 codificata.
## Valori restituiti
La `consent_tcf_v2_decode` funzione restituisce un dizionario contenente i dati di consenso decodificati da una stringa di consenso Transparency and Consent Framework (TCF) v2.
Il dizionario restituito include le seguenti coppie chiave-valore:
**Segmento principale**
+ `version`: La versione della specifica TCF utilizzata (attualmente 2).
+ `created`: La data e l'ora in cui è stata creata la stringa di consenso.
+ `lastUpdated`: la data e l'ora dell'ultimo aggiornamento della stringa di consenso.
+ `cmpId`: l'ID della piattaforma di gestione del consenso (CMP) che ha codificato la stringa di consenso.
+ `cmpVersion`: la versione della CMP che ha codificato la stringa di consenso.
+ `consentScreen`: L'ID della schermata nell'interfaccia utente CMP in cui l'utente ha fornito il consenso.
+ `consentLanguage`: Il codice della lingua delle informazioni sul consenso.
+ `vendorListVersion`: la versione dell'elenco dei fornitori utilizzata.
+ `tcfPolicyVersion`: La versione della politica TCF su cui si basa la stringa di consenso.
+ `isServiceSpecific`: Un valore booleano che indica se il consenso è specifico per un particolare servizio o si applica a tutti i servizi.
+ `useNonStandardStacks`: Un valore booleano che indica se vengono utilizzati pile non standard.
+ `specialFeatureOptIns`: Un elenco di numeri interi che rappresentano le funzioni speciali che l'utente ha scelto di utilizzare.
+ `purposeConsent`: Un elenco di numeri interi che rappresentano gli scopi per i quali l'utente ha acconsentito.
+ `purposesLITransparency`: Un elenco di numeri interi che rappresentano gli scopi per i quali l'utente ha garantito la trasparenza degli interessi legittimi.
+ `purposeOneTreatment`: Un valore booleano che indica se l'utente ha richiesto lo «scopo unico del trattamento» (ovvero, tutti gli scopi sono trattati allo stesso modo).
+ `publisherCountryCode`: Il codice del paese dell'editore.
+ `vendorConsent`: un elenco di fornitori a IDs cui l'utente ha acconsentito.
+ `vendorLegitimateInterest`: Un elenco di fornitori IDs per i quali l'interesse legittimo dell'utente è stato comunicato in modo trasparente.
+ `pubRestrictionEntry`: Un elenco di restrizioni per gli editori. Questo campo contiene l'ID dello scopo, il tipo di restrizione e l'elenco dei fornitori IDs soggetti a tale restrizione.
**Segmento di fornitore divulgato**
+ `disclosedVendors`: un elenco di numeri interi che rappresentano i fornitori che sono stati resi noti all'utente.
**Segmento relativo agli scopi del publisher**
+ `pubPurposesConsent`: un elenco di numeri interi che rappresentano gli scopi specifici dell'editore per i quali l'utente ha dato il consenso.
+ `pubPurposesLITransparency`: Un elenco di numeri interi che rappresentano gli scopi specifici dell'editore per i quali l'utente ha garantito la trasparenza degli interessi legittimi.
+ `customPurposesConsent`: Un elenco di numeri interi che rappresentano gli scopi personalizzati per i quali l'utente ha dato il consenso.
+ `customPurposesLITransparency`: Un elenco di numeri interi che rappresentano gli scopi personalizzati per i quali l'utente ha garantito la trasparenza degli interessi legittimi.
Questi dati di consenso dettagliati possono essere utilizzati per comprendere e rispettare le preferenze di privacy dell'utente quando lavora con dati personali.
## Esempio
L'esempio seguente utilizza un singolo argomento, che è la stringa di consenso codificata. Restituisce un dizionario contenente i dati di consenso decodificati, comprese le informazioni sulle preferenze di privacy dell'utente, le scelte di consenso e altri metadati.
```
from aws_clean_rooms.functions import consent_tcf_v2_decode
consent_string = "CO1234567890abcdef"
consent_data = consent_tcf_v2_decode(consent_string)
print(consent_data)
```
La struttura di base dei dati di consenso restituiti include informazioni sulla versione della stringa di consenso, i dettagli della CMP (Consent Management Platform), il consenso dell'utente e le scelte di interesse legittimo per scopi e fornitori diversi e altri metadati.
```
/** core segment **/
version: 2,
created: "2023-10-01T12:00:00Z",
lastUpdated: "2023-10-01T12:00:00Z",
cmpId: 1234,
cmpVersion: 5,
consentScreen: 1,
consentLanguage: "en",
vendorListVersion: 2,
tcfPolicyVersion: 2,
isServiceSpecific: false,
useNonStandardStacks: false,
specialFeatureOptIns: [1, 2, 3],
purposeConsent: [1, 2, 3],
purposesLITransparency: [1, 2, 3],
purposeOneTreatment: true,
publisherCountryCode: "US",
vendorConsent: [1, 2, 3],
vendorLegitimateInterest: [1, 2, 3],
pubRestrictionEntry: [
{ purpose: 1, restrictionType: 2, restrictionDescription: "Example restriction" },
],
/** disclosed vendor segment **/
disclosedVendors: [1, 2, 3],
/** publisher purposes segment **/
pubPurposesConsent: [1, 2, 3],
pubPurposesLITransparency: [1, 2, 3],
customPurposesConsent: [1, 2, 3],
customPurposesLITransparency: [1, 2, 3],
};
```
# Funzioni finestra
Le funzioni finestra ti consentono di creare query aziendali analitiche in modo più efficiente. Le funzioni finestra operano su una partizione o "finestra" di un insieme di risultati e restituiscono un valore per ogni riga in quella finestra. Tuttavia, le funzioni non finestra eseguono i calcoli in relazione a ogni riga del set di risultati. A differenza delle funzioni di gruppo che aggregano le righe dei risultati, le funzioni finestra mantengono tutte le righe nell'espressione della tabella.
I valori restituiti sono calcolati utilizzando i valori dai set di righe in quella finestra. Per ogni riga nella tabella, la finestra definisce un set di righe che viene utilizzato per calcolare gli attributi aggiuntivi. Una finestra viene definita utilizzando una specifica della finestra (la clausola OVER) e si basa su tre concetti principali:
+ *Partizionamento della finestra,* che forma gruppi di righe (clausola PARTITION)
+ *Ordinamento della finestra*, che definisce un ordine o una sequenza di righe all'interno di ciascuna partizione (clausola ORDER BY)
+ *Frame della finestra*, che sono definiti in relazione a ciascuna riga per restringere ulteriormente l'insieme di righe (specifica ROWS)
Le funzioni finestra sono l'ultimo insieme di operazioni eseguite in una query ad eccezione della clausola ORDER BY finale. Tutti i join e tutte le clausole WHERE, GROUP BY e HAVING vengono completati prima che le funzioni finestra vengano elaborate. Pertanto, le funzioni finestra possono essere visualizzate solo nell'elenco di selezione o nella clausola ORDER BY. È possibile utilizzare più funzioni finestra all'interno di una singola query con diverse clausole del frame. È inoltre possibile utilizzare le funzioni finestra in altre espressioni scalari, come ad esempio CASE.
## Riepilogo della sintassi della funzione finestra
Le funzioni della finestra seguono una sintassi standard, che è la seguente.
```
function (expression) OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list [ frame_clause ] ] )
```
Qui, *function* è una delle funzioni descritte in questa sezione.
L'*expr\$1list* è il seguente.
```
expression | column_name [, expr_list ]
```
L'*order\$1list* è il seguente.
```
expression | column_name [ ASC | DESC ]
[ NULLS FIRST | NULLS LAST ]
[, order_list ]
```
La *frame\$1clause* è la seguente.
```
ROWS
{ UNBOUNDED PRECEDING | unsigned_value PRECEDING | CURRENT ROW } |
{ BETWEEN
{ UNBOUNDED PRECEDING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW}
AND
{ UNBOUNDED FOLLOWING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW }}
```
### Arguments (Argomenti)
*funzione*
La funzione finestra. Per informazioni dettagliate, vedere le descrizioni della singola funzione.
OVER
La clausola che definisce la specifica della finestra. La clausola OVER è obbligatoria per le funzioni finestra e le contraddistingue da altre funzioni SQL.
PARTITION BY *expr\$1list*
(Facoltativo) La clausola PARTITION BY suddivide il set di risultati in partizioni in modo molto simile alla clausola GROUP BY. Se è presente una clausola di partizione, la funzione viene calcolata per le righe in ogni partizione. Se non viene specificata alcuna clausola di partizione, una singola partizione contiene l'intera tabella e la funzione viene calcolata per quella tabella completa.
Le funzioni di classificazione DENSE\$1RANK, NTILE, RANK e ROW\$1NUMBER richiedono un confronto globale di tutte le righe nell'insieme di risultati. Quando viene utilizzata una clausola PARTITION BY, l'ottimizzatore della query può eseguire ciascuna aggregazione in parallelo distribuendo il carico di lavoro su più sezioni in base alle partizioni. Se la clausola PARTITION BY non è presente, la fase di aggregazione deve essere eseguita in serie su una singola sezione, che può avere un impatto negativo significativo sulle prestazioni, in particolare per i cluster di grandi dimensioni.
AWS Clean Roomsnon supporta stringhe letterali nelle clausole PARTITION BY.
ORDER BY *order\$1list*
(Facoltativo) La funzione finestra viene applicata alle righe all'interno di ciascuna partizione ordinata in base alla specifica dell'ordine in ORDER BY. Questa clausola ORDER BY è distinta e completamente non correlata a una clausola ORDER BY in una *frame\$1clause*. La clausola ORDER BY può essere utilizzata senza la clausola PARTITION BY.
Per le funzioni di classificazione, la clausola ORDER BY identifica le misure per i valori di classificazione. Per le funzioni di aggregazione, le righe partizionate devono essere ordinate prima che la funzione di aggregazione sia calcolata per ciascun frame. Per ulteriori informazioni sui tipi di funzione finestra, consultare [Funzioni finestra](#Window_functions).
Gli identificatori o le espressioni di colonna che valutano gli identificatori di colonna sono obbligatori nell'elenco degli ordini. Né le costanti né le espressioni costanti possono essere utilizzate come sostituti dei nomi delle colonne.
I valori NULL vengono trattati come il proprio gruppo, ordinati e classificati in base all'opzione NULLS FIRST o NULLS LAST. Per impostazione predefinita, i valori NULL vengono ordinati e classificati per ultimi in ordine ASC e ordinati e classificati per primi in ordine DESC.
AWS Clean Roomsnon supporta stringhe letterali nelle clausole ORDER BY.
Se viene omessa la clausola ORDER BY, l'ordine delle righe non è deterministico.
In qualsiasi sistema paralleloAWS Clean Rooms, ad esempio quando una clausola ORDER BY non produce un ordinamento unico e totale dei dati, l'ordine delle righe non è deterministico. In altre parole, se l'espressione ORDER BY produce valori duplicati (un ordinamento parziale), l'ordine di restituzione di tali righe potrebbe variare da una sequenza all'altra. AWS Clean Rooms A loro volta, le funzioni finestra potrebbero restituire risultati inattesi o incoerenti. Per ulteriori informazioni, consulta [Ordinamento univoco dei dati per le funzioni finestra](#Examples_order_by_WF).
*column\$1name*
Nome di una colonna da partizionare o da ordinare.
ASC \$1 DESC
Opzione che definisce l'ordinamento per l'espressione, come segue:
+ ASC: crescente (ad esempio, dal più piccolo al più grande per i valori numerici e da 'A' a 'Z' per le stringhe di caratteri). Se non viene specificata alcuna opzione, i dati vengono ordinati in ordine crescente per impostazione predefinita.
+ DESC: decrescente (ad esempio, dal più grande al più piccolo per i valori numerici e da 'Z' ad 'A' per le stringhe).
NULLS FIRST \$1 NULLS LAST
Opzione che specifica se NULLS deve essere ordinato per primo, prima di valori non null, o per ultimo, dopo valori non null. Per impostazione predefinita, i NULLS vengono ordinati e classificati per ultimi in ordine ASC e ordinati e classificati per primi in ordine DESC.
*frame\$1clause*
Per le funzioni di aggregazione, la clausola frame perfeziona ulteriormente l'insieme di righe in una finestra della funzione quando si utilizza ORDER BY. Fornisce la capacità di includere o escludere set di righe all'interno del risultato ordinato. La clausola frame è composta dalla parola chiave ROWS e dagli specificatori associati.
La clausola frame non si applica alle funzioni di classificazione. Inoltre, la clausola frame non è richiesta quando non viene utilizzata alcuna clausola ORDER BY nella clausola OVER per una funzione di aggregazione. Se una clausola ORDER BY viene utilizzata per una funzione di aggregazione, è necessaria una clausola del frame esplicita.
Quando non viene specificata alcuna clausola ORDER BY, il frame implicito è illimitato: equivalente a ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING.
ROWS
Questa clausola definisce il frame della finestra specificando una compensazione fisica dalla riga corrente.
Questa clausola specifica le righe nella finestra o partizione corrente con cui deve essere combinato il valore nella riga corrente. Usa argomenti che specificano la posizione della riga, che può essere prima o dopo la riga corrente. Il punto di riferimento per tutti i frame della finestra è la riga corrente. Ogni riga diventa a sua volta la riga corrente mentre il frame della finestra scorre in avanti nella partizione.
Il frame può essere un semplice insieme di righe fino a includere la riga corrente:
```
{UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW}
```
Oppure può essere un insieme di righe tra due limiti.
```
BETWEEN
{ UNBOUNDED PRECEDING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
AND
{ UNBOUNDED FOLLOWING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
```
UNBOUNDED PRECEDING indica che la finestra inizia nella prima riga della partizione; *offset* PRECEDING indica che la finestra inizia un numero di righe equivalente al valore di compensazione prima della riga corrente. UNBOUNDED PRECEDING è il valore predefinito.
CURRENT ROW indica che la finestra inizia o termina nella riga corrente.
UNBOUNDED FOLLOWING indica che la finestra termina nell'ultima riga della partizione; *offset* FOLLOWING indica che la finestra termina un numero di righe equivalente al valore di compensazione dopo la riga corrente.
*offset* identifica un numero fisico di righe prima o dopo la riga corrente. In questo caso, *offset* deve essere una costante che valuta un valore numerico positivo. Ad esempio, 5 FOLLOWING terminerà il frame 5 righe dopo la riga corrente.
Laddove BETWEEN non viene specificato, il frame è implicitamente limitato dalla riga corrente. Ad esempio, `ROWS 5 PRECEDING` è uguale a `ROWS BETWEEN 5 PRECEDING AND CURRENT ROW`. Inoltre, `ROWS UNBOUNDED FOLLOWING` è uguale a `ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING`.
Non è possibile specificare un frame in cui il limite iniziale è maggiore del limite finale. Ad esempio, non è possibile specificare nessuno di questi frame:
```
between 5 following and 5 preceding
between current row and 2 preceding
between 3 following and current row
```
## Ordinamento univoco dei dati per le funzioni finestra
Se una clausola ORDER BY per una funzione finestra non produce un ordinamento univoco e totale dei dati, l'ordine delle righe è non deterministico. Se l'espressione ORDER BY produce valori duplicati (un ordinamento parziale), l'ordine di restituzione di tali righe può variare in più esecuzioni. In questo caso, le funzioni finestra possono restituire risultati inattesi o incoerenti.
Ad esempio, la seguente query restituisce risultati diversi su più esecuzioni. Si ottengono questi risultati diversi perché `order by dateid` non genera un ordinamento univoco dei dati per la funzione finestra SUM.
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 1730.00 | 1730.00
1827 | 708.00 | 2438.00
1827 | 234.00 | 2672.00
...
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 234.00 | 234.00
1827 | 472.00 | 706.00
1827 | 347.00 | 1053.00
...
```
In questo caso, l'aggiunta di una seconda colonna ORDER BY alla funzione finestra potrebbe risolvere il problema.
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid, pricepaid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+---------
1827 | 234.00 | 234.00
1827 | 337.00 | 571.00
1827 | 347.00 | 918.00
...
```
## Funzioni supportate
AWS Clean RoomsSpark SQL supporta due tipi di funzioni delle finestre: aggregate e di classificazione.
Queste sono le funzioni di aggregazione supportate:
+ [Funzione finestra CUME\$1DIST](WF_CUME_DIST.md)
+ [Funzione finestra DENSE\$1RANK](WF_DENSE_RANK.md)
+ [Funzione FIRST window](WF_FIRST.md)
+ [Funzione finestra FIRST\$1VALUE](WF_first_value.md)
+ [Funzione finestra LAG](WF_LAG.md)
+ [funzione LAST window](WF-LAST.md)
+ [Funzione finestra LAST\$1VALUE](WF_last_value.md)
+ [Funzione finestra LEAD](WF_LEAD.md)
Queste sono le funzioni di classificazione supportate:
+ [Funzione finestra DENSE\$1RANK](WF_DENSE_RANK.md)
+ [Funzione finestra PERCENT\$1RANK](WF_PERCENT_RANK.md)
+ [Funzione finestra RANK](WF_RANK.md)
+ [Funzione finestra ROW\$1NUMBER](WF_ROW_NUMBER.md)
## Tabella di esempio per gli esempi della funzione finestra
Sono presenti esempi di funzione finestra specifici con la descrizione di ogni funzione. Alcuni esempi utilizzano una tabella denominata WINSALES, che contiene 11 righe, come illustrato nella tabella seguente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/clean-rooms/latest/sql-reference/Window_functions.html)
# Funzione finestra CUME\$1DIST
Calcola la distribuzione cumulativa di un valore all'interno di una finestra o partizione. Supponendo l'ordinamento ascendente, la distribuzione cumulativa è determinata utilizzando questa formula:
`count of rows with values <= x / count of rows in the window or partition`
laddove *x* è uguale al valore nella riga corrente della colonna specificata nella clausola ORDER BY. Il seguente insieme di dati dimostra l'uso di questa formula:
```
Row# Value Calculation CUME_DIST
1 2500 (1)/(5) 0.2
2 2600 (2)/(5) 0.4
3 2800 (3)/(5) 0.6
4 2900 (4)/(5) 0.8
5 3100 (5)/(5) 1.0
```
L'intervallo del valore di restituzione è compreso tra 0 e 1, con questi valori compresi.
## Sintassi
```
CUME_DIST ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Arguments (Argomenti)
OVER
Una clausola che specifica il partizionamento della finestra. La clausola OVER non può contenere una specifica del frame della finestra.
PARTITION BY *partition\$1expression*
Opzionale. Un'espressione che imposta l'intervallo di registrazioni per ciascun gruppo nella clausola OVER.
ORDER BY *order\$1list*
L'espressione su cui calcolare la distribuzione cumulativa. L'espressione deve avere o un tipo di dati numerici o essere implicitamente convertibile in uno. Se ORDER BY viene omesso, il valore di restituzione è 1 per tutte le righe.
Se ORDER BY non produce un ordinamento univoco, l'ordine delle righe è non deterministico. Per ulteriori informazioni, consulta [Ordinamento univoco dei dati per le funzioni finestra](Window_functions.md#Examples_order_by_WF).
## Tipo restituito
FLOAT8
## Esempi
L'esempio seguente calcola la distribuzione cumulativa della quantità per ciascun venditore:
```
select sellerid, qty, cume_dist()
over (partition by sellerid order by qty)
from winsales;
sellerid qty cume_dist
--------------------------------------------------
1 10.00 0.33
1 10.64 0.67
1 30.37 1
3 10.04 0.25
3 15.15 0.5
3 20.75 0.75
3 30.55 1
2 20.09 0.5
2 20.12 1
4 10.12 0.5
4 40.23 1
```
Per una descrizione della tabella WINSALES, consultare [Tabella di esempio per gli esempi della funzione finestra](Window_functions.md#Window_function_example).
# Funzione finestra DENSE\$1RANK
La funzione finestra DENSE\$1RANK determina la classificazione di un valore in un gruppo di valori, in base all'espressione ORDER BY nella clausola OVER. Se è presente la clausola PARTITION BY facoltativa, le classificazioni vengono ripristinate per ciascun gruppo di righe. Righe con valori uguali per i criteri di classificazione ricevono la stessa classificazione. La funzione DENSE\$1RANK differisce da RANK per un aspetto: se due o più righe si legano, non c'è spazio nella sequenza dei valori classificati. Ad esempio, se due righe sono classificate come 1, il livello successivo è 2.
È possibile avere funzioni di classificazione con diverse clausole PARTITION BY e ORDER BY nella stessa query.
## Sintassi
```
DENSE_RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Arguments (Argomenti)
( )
La funzione non accetta argomenti, ma le parentesi vuote sono obbligatorie.
OVER
Le clausole finestra per la funzione DENSE\$1RANK.
PARTITION BY *expr\$1list*
Opzionale. Una o più espressioni che definiscono la finestra.
ORDER BY *order\$1list*
Opzionale. L'espressione su cui si basano i valori di classificazione. Se non viene specificato nessun PARTITION BY, ORDER BY utilizza l'intera tabella. Se ORDER BY viene omesso, il valore di restituzione è 1 per tutte le righe.
Se ORDER BY non produce un ordinamento univoco, l'ordine delle righe è non deterministico. Per ulteriori informazioni, consulta [Ordinamento univoco dei dati per le funzioni finestra](Window_functions.md#Examples_order_by_WF).
## Tipo restituito
INTEGER
## Esempi
Nel seguente esempio viene ordinata la tabella in base alla quantità venduta (in ordine decrescente) e viene assegnata una classificazione densa e una classificazione regolare a ciascuna riga. I risultati vengono ordinati dopo aver applicato i risultati della funzione finestra.
```
select salesid, qty,
dense_rank() over(order by qty desc) as d_rnk,
rank() over(order by qty desc) as rnk
from winsales
order by 2,1;
salesid | qty | d_rnk | rnk
---------+-----+-------+-----
10001 | 10 | 5 | 8
10006 | 10 | 5 | 8
30001 | 10 | 5 | 8
40005 | 10 | 5 | 8
30003 | 15 | 4 | 7
20001 | 20 | 3 | 4
20002 | 20 | 3 | 4
30004 | 20 | 3 | 4
10005 | 30 | 2 | 2
30007 | 30 | 2 | 2
40001 | 40 | 1 | 1
(11 rows)
```
Notare la differenza nelle classificazioni assegnate allo stesso insieme di righe quando le funzioni DENSE\$1RANK e RANK vengono utilizzate fianco a fianco nella stessa query. Per una descrizione della tabella WINSALES, consultare [Tabella di esempio per gli esempi della funzione finestra](Window_functions.md#Window_function_example).
Nel seguente esempio la tabella viene partizionata per SELLERID, ciascuna partizione viene ordinata in base alla quantità (in ordine decrescente) e viene assegnata una classificazione densa a ciascuna riga. I risultati vengono ordinati dopo aver applicato i risultati della funzione finestra.
```
select salesid, sellerid, qty,
dense_rank() over(partition by sellerid order by qty desc) as d_rnk
from winsales
order by 2,3,1;
salesid | sellerid | qty | d_rnk
---------+----------+-----+-------
10001 | 1 | 10 | 2
10006 | 1 | 10 | 2
10005 | 1 | 30 | 1
20001 | 2 | 20 | 1
20002 | 2 | 20 | 1
30001 | 3 | 10 | 4
30003 | 3 | 15 | 3
30004 | 3 | 20 | 2
30007 | 3 | 30 | 1
40005 | 4 | 10 | 2
40001 | 4 | 40 | 1
(11 rows)
```
Per una descrizione della tabella WINSALES, consultare [Tabella di esempio per gli esempi della funzione finestra](Window_functions.md#Window_function_example).
# Funzione FIRST window
Dato un insieme ordinato di righe, FIRST restituisce il valore dell'espressione specificata rispetto alla prima riga nella cornice della finestra.
Per informazioni sulla selezione dell'ultima riga nel frame, consulta [funzione LAST window](WF-LAST.md).
## Sintassi
```
FIRST( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Arguments (Argomenti)
*espressione*
L'espressione o colonna di destinazione su cui viene eseguita la funzione.
IGNORE NULLS
Quando questa opzione viene utilizzata con FIRST, la funzione restituisce il primo valore nel frame che non è NULL (o NULL se tutti i valori sono NULL).
RESPECT NULLS
Indica che AWS Clean Rooms deve includere valori nulli nella determinazione della riga da utilizzare. RESPECT NULLS è supportato come impostazione predefinita se non si specifica IGNORE NULLS.
OVER
Presenta le clausole finestra per la funzione.
PARTITION BY *expr\$1list*
Definisce la finestra per la funzione in termini di una o più espressioni.
ORDER BY *order\$1list*
Ordina le righe all'interno di ogni partizione. Se non viene specificata nessuna clausola PARTITION BY, ORDER BY ordina l'intera tabella. Se si specifica una clausola ORDER BY, è necessario anche specificare una *frame\$1clause*.
I risultati della funzione FIRST dipendono dall'ordine dei dati. I risultati sono non deterministici nei seguenti casi:
+ Quando non è specificata alcuna clausola ORDER BY e una partizione contiene due valori diversi per un'espressione
+ Quando l'espressione valuta valori diversi che corrispondono allo stesso valore nell'elenco ORDER BY.
*frame\$1clause*
Se una clausola ORDER BY viene utilizzata per una funzione di aggregazione, è necessaria una clausola del frame esplicita. La clausola frame raffina l'insieme di righe in una finestra della funzione, includendo o escludendo insieme di righe nel risultato ordinato. La clausola frame è composta dalla parola chiave ROWS e dagli specificatori associati. Per informazioni, consulta [Riepilogo della sintassi della funzione finestra](Window_functions.md#Window_function_synopsis).
## Tipo restituito
Queste funzioni supportano espressioni che utilizzano tipi di AWS Clean Rooms dati primitivi. Il tipo restituito è lo stesso del tipo di dati di *expression*.
## Esempi
L'esempio seguente restituisce la capacità di posto per ciascuna posizione nella tabella VENUE, con i risultati ordinati in base alla capacità (da alta a bassa). La funzione FIRST viene utilizzata per selezionare il nome della sede che corrisponde alla prima fila del riquadro: in questo caso, la fila con il maggior numero di posti. I risultati sono partizionati per stato, quindi quando il valore VENUESTATE cambia, viene selezionato un nuovo primo valore. Il frame della finestra è illimitato, quindi lo stesso primo valore è selezionato per ogni riga in ogni partizione.
Per la California, `Qualcomm Stadium` ha il più alto numero di posti (`70561`), quindi questo nome è il primo valore per tutte le righe nella partizione `CA`.
```
select venuestate, venueseats, venuename,
first(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
CA | 63026 | McAfee Coliseum | Qualcomm Stadium
CA | 56000 | Dodger Stadium | Qualcomm Stadium
CA | 45050 | Angel Stadium of Anaheim | Qualcomm Stadium
CA | 42445 | PETCO Park | Qualcomm Stadium
CA | 41503 | AT&T Park | Qualcomm Stadium
CA | 22000 | Shoreline Amphitheatre | Qualcomm Stadium
CO | 76125 | INVESCO Field | INVESCO Field
CO | 50445 | Coors Field | INVESCO Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Dolphin Stadium
FL | 73800 | Jacksonville Municipal Stadium | Dolphin Stadium
FL | 65647 | Raymond James Stadium | Dolphin Stadium
FL | 36048 | Tropicana Field | Dolphin Stadium
...
```
# Funzione finestra FIRST\$1VALUE
Dato un insieme ordinato di righe, FIRST\$1VALUE restituisce il valore dell'espressione specificata rispetto alla prima riga nel frame della finestra.
Per informazioni sulla selezione dell'ultima riga nel frame, consulta [Funzione finestra LAST\$1VALUE](WF_last_value.md).
## Sintassi
```
FIRST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Arguments (Argomenti)
*espressione*
L'espressione o colonna di destinazione su cui viene eseguita la funzione.
IGNORE NULLS
Quando questa opzione viene utilizzata con FIRST\$1VALUE, la funzione restituisce il primo valore nel frame che non è NULL (o NULL se tutti i valori sono NULL).
RESPECT NULLS
Indica che AWS Clean Rooms deve includere valori nulli nella determinazione della riga da utilizzare. RESPECT NULLS è supportato come impostazione predefinita se non si specifica IGNORE NULLS.
OVER
Presenta le clausole finestra per la funzione.
PARTITION BY *expr\$1list*
Definisce la finestra per la funzione in termini di una o più espressioni.
ORDER BY *order\$1list*
Ordina le righe all'interno di ogni partizione. Se non viene specificata nessuna clausola PARTITION BY, ORDER BY ordina l'intera tabella. Se si specifica una clausola ORDER BY, è necessario anche specificare una *frame\$1clause*.
I risultati della funzione FIRST\$1VALUE dipendono dall'ordinamento dei dati. I risultati sono non deterministici nei seguenti casi:
+ Quando non è specificata alcuna clausola ORDER BY e una partizione contiene due valori diversi per un'espressione
+ Quando l'espressione valuta valori diversi che corrispondono allo stesso valore nell'elenco ORDER BY.
*frame\$1clause*
Se una clausola ORDER BY viene utilizzata per una funzione di aggregazione, è necessaria una clausola del frame esplicita. La clausola frame raffina l'insieme di righe in una finestra della funzione, includendo o escludendo insieme di righe nel risultato ordinato. La clausola frame è composta dalla parola chiave ROWS e dagli specificatori associati. Per informazioni, consulta [Riepilogo della sintassi della funzione finestra](Window_functions.md#Window_function_synopsis).
## Tipo restituito
Queste funzioni supportano espressioni che utilizzano tipi di AWS Clean Rooms dati primitivi. Il tipo restituito è lo stesso del tipo di dati di *expression*.
## Esempi
L'esempio seguente restituisce la capacità di posto per ciascuna posizione nella tabella VENUE, con i risultati ordinati in base alla capacità (da alta a bassa). La funzione FIRST\$1VALUE viene utilizzata per selezionare il nome del luogo corrispondente alla prima riga nel frame: in questo caso, la riga con il numero più alto di posti. I risultati sono partizionati per stato, quindi quando il valore VENUESTATE cambia, viene selezionato un nuovo primo valore. Il frame della finestra è illimitato, quindi lo stesso primo valore è selezionato per ogni riga in ogni partizione.
Per la California, `Qualcomm Stadium` ha il più alto numero di posti (`70561`), quindi questo nome è il primo valore per tutte le righe nella partizione `CA`.
```
select venuestate, venueseats, venuename,
first_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
CA | 63026 | McAfee Coliseum | Qualcomm Stadium
CA | 56000 | Dodger Stadium | Qualcomm Stadium
CA | 45050 | Angel Stadium of Anaheim | Qualcomm Stadium
CA | 42445 | PETCO Park | Qualcomm Stadium
CA | 41503 | AT&T Park | Qualcomm Stadium
CA | 22000 | Shoreline Amphitheatre | Qualcomm Stadium
CO | 76125 | INVESCO Field | INVESCO Field
CO | 50445 | Coors Field | INVESCO Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Dolphin Stadium
FL | 73800 | Jacksonville Municipal Stadium | Dolphin Stadium
FL | 65647 | Raymond James Stadium | Dolphin Stadium
FL | 36048 | Tropicana Field | Dolphin Stadium
...
```
# Funzione finestra LAG
La funzione finestra LAG restituisce i valori per una riga a una data compensazione sopra (prima) la riga corrente nella partizione.
## Sintassi
```
LAG (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Arguments (Argomenti)
*value\$1expr*
L'espressione o colonna di destinazione su cui viene eseguita la funzione.
*offset*
Un parametro facoltativo che specifica il numero di righe prima della riga corrente per le quali restituire i valori. La compensazione può essere un integer costante o un'espressione che valuta un integer. Se non si specifica un offset, AWS Clean Rooms viene utilizzato `1` come valore predefinito. Una compensazione di `0` indica la riga corrente.
IGNORE NULLS
Una specifica facoltativa che indica che i valori nulli AWS Clean Rooms devono essere ignorati nella determinazione della riga da utilizzare. I valori null sono inclusi se IGNORE NULLS non è elencato.
È possibile utilizzare un'espressione NVL o COALESCE per sostituire i valori null con un altro valore.
RESPECT NULLS
Indica che AWS Clean Rooms deve includere valori nulli nella determinazione della riga da utilizzare. RESPECT NULLS è supportato come impostazione predefinita se non si specifica IGNORE NULLS.
OVER
Specifica il partizionamento e l'ordinamento della finestra. La clausola OVER non può contenere una specifica del frame della finestra.
PARTITION BY *window\$1partition*
Un argomento facoltativo che imposta l'intervallo di registrazioni per ciascun gruppo nella clausola OVER.
ORDER BY *window\$1ordering*
Ordina le righe all'interno di ogni partizione.
La funzione della finestra LAG supporta espressioni che utilizzano qualsiasi tipo di AWS Clean Rooms dati. Il tipo di restituzione è lo stesso del tipo di dati di *value\$1expr*.
## Esempi
L'esempio seguente mostra la quantità di biglietti venduti all'acquirente con un ID acquirente di 3 e il tempo in cui l'acquirente 3 ha acquistato i biglietti. Per confrontare ogni vendita con la vendita precedente per l'acquirente 3, la query restituisce la quantità venduta per ogni vendita precedente. Poiché non è stato effettuato alcun acquisto prima del 16/01/2008, il primo valore venduto precedentemente è null:
```
select buyerid, saletime, qtysold,
lag(qtysold,1) over (order by buyerid, saletime) as prev_qtysold
from sales where buyerid = 3 order by buyerid, saletime;
buyerid | saletime | qtysold | prev_qtysold
---------+---------------------+---------+--------------
3 | 2008-01-16 01:06:09 | 1 |
3 | 2008-01-28 02:10:01 | 1 | 1
3 | 2008-03-12 10:39:53 | 1 | 1
3 | 2008-03-13 02:56:07 | 1 | 1
3 | 2008-03-29 08:21:39 | 2 | 1
3 | 2008-04-27 02:39:01 | 1 | 2
3 | 2008-08-16 07:04:37 | 2 | 1
3 | 2008-08-22 11:45:26 | 2 | 2
3 | 2008-09-12 09:11:25 | 1 | 2
3 | 2008-10-01 06:22:37 | 1 | 1
3 | 2008-10-20 01:55:51 | 2 | 1
3 | 2008-10-28 01:30:40 | 1 | 2
(12 rows)
```
# funzione LAST window
Dato un insieme ordinato di righe, la funzione LAST restituisce il valore dell'espressione rispetto all'ultima riga del frame.
Per informazioni sulla selezione della prima riga nel frame, consulta [Funzione FIRST window](WF_FIRST.md).
## Sintassi
```
LAST( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Arguments (Argomenti)
*espressione*
L'espressione o colonna di destinazione su cui viene eseguita la funzione.
IGNORE NULLS
La funzione restituisce l'ultimo valore nel frame che non è NULL (o NULL se tutti i valori sono NULL).
RESPECT NULLS
Indica che AWS Clean Rooms deve includere valori nulli nella determinazione della riga da utilizzare. RESPECT NULLS è supportato come impostazione predefinita se non si specifica IGNORE NULLS.
OVER
Presenta le clausole finestra per la funzione.
PARTITION BY *expr\$1list*
Definisce la finestra per la funzione in termini di una o più espressioni.
ORDER BY *order\$1list*
Ordina le righe all'interno di ogni partizione. Se non viene specificata nessuna clausola PARTITION BY, ORDER BY ordina l'intera tabella. Se si specifica una clausola ORDER BY, è necessario anche specificare una *frame\$1clause*.
I risultati dipendono dall'ordinamento dei dati. I risultati sono non deterministici nei seguenti casi:
+ Quando non è specificata alcuna clausola ORDER BY e una partizione contiene due valori diversi per un'espressione
+ Quando l'espressione valuta valori diversi che corrispondono allo stesso valore nell'elenco ORDER BY.
*frame\$1clause*
Se una clausola ORDER BY viene utilizzata per una funzione di aggregazione, è necessaria una clausola del frame esplicita. La clausola frame raffina l'insieme di righe in una finestra della funzione, includendo o escludendo insieme di righe nel risultato ordinato. La clausola frame è composta dalla parola chiave ROWS e dagli specificatori associati. Per informazioni, consulta [Riepilogo della sintassi della funzione finestra](Window_functions.md#Window_function_synopsis).
## Tipo restituito
Queste funzioni supportano espressioni che utilizzano tipi di AWS Clean Rooms dati primitivi. Il tipo restituito è lo stesso del tipo di dati di *expression*.
## Esempi
L'esempio seguente restituisce la capacità di posto per ciascuna posizione nella tabella VENUE, con i risultati ordinati in base alla capacità (da alta a bassa). La funzione LAST viene utilizzata per selezionare il nome della sede che corrisponde all'ultima riga del riquadro: in questo caso, la fila con il minor numero di posti. I risultati sono partizionati per stato, quindi quando il valore VENUESTATE cambia, viene selezionato un nuovo ultimo valore. Il frame della finestra è illimitato, quindi lo stesso ultimo valore è selezionato per ogni riga in ogni partizione.
Per la California, `Shoreline Amphitheatre` viene restituito per ogni riga nella partizione perché ha il numero più basso di posti (`22000`).
```
select venuestate, venueseats, venuename,
last(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | last
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Shoreline Amphitheatre
CA | 69843 | Monster Park | Shoreline Amphitheatre
CA | 63026 | McAfee Coliseum | Shoreline Amphitheatre
CA | 56000 | Dodger Stadium | Shoreline Amphitheatre
CA | 45050 | Angel Stadium of Anaheim | Shoreline Amphitheatre
CA | 42445 | PETCO Park | Shoreline Amphitheatre
CA | 41503 | AT&T Park | Shoreline Amphitheatre
CA | 22000 | Shoreline Amphitheatre | Shoreline Amphitheatre
CO | 76125 | INVESCO Field | Coors Field
CO | 50445 | Coors Field | Coors Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Tropicana Field
FL | 73800 | Jacksonville Municipal Stadium | Tropicana Field
FL | 65647 | Raymond James Stadium | Tropicana Field
FL | 36048 | Tropicana Field | Tropicana Field
...
```
# Funzione finestra LAST\$1VALUE
In un set di righe ordinato, la funzione LAST\$1VALUE restituisce il valore dell'espressione rispetto all'ultima riga nel frame.
Per informazioni sulla selezione della prima riga nel frame, consulta [Funzione finestra FIRST\$1VALUE](WF_first_value.md).
## Sintassi
```
LAST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Arguments (Argomenti)
*espressione*
L'espressione o colonna di destinazione su cui viene eseguita la funzione.
IGNORE NULLS
La funzione restituisce l'ultimo valore nel frame che non è NULL (o NULL se tutti i valori sono NULL).
RESPECT NULLS
Indica che AWS Clean Rooms deve includere valori nulli nella determinazione della riga da utilizzare. RESPECT NULLS è supportato come impostazione predefinita se non si specifica IGNORE NULLS.
OVER
Presenta le clausole finestra per la funzione.
PARTITION BY *expr\$1list*
Definisce la finestra per la funzione in termini di una o più espressioni.
ORDER BY *order\$1list*
Ordina le righe all'interno di ogni partizione. Se non viene specificata nessuna clausola PARTITION BY, ORDER BY ordina l'intera tabella. Se si specifica una clausola ORDER BY, è necessario anche specificare una *frame\$1clause*.
I risultati dipendono dall'ordinamento dei dati. I risultati sono non deterministici nei seguenti casi:
+ Quando non è specificata alcuna clausola ORDER BY e una partizione contiene due valori diversi per un'espressione
+ Quando l'espressione valuta valori diversi che corrispondono allo stesso valore nell'elenco ORDER BY.
*frame\$1clause*
Se una clausola ORDER BY viene utilizzata per una funzione di aggregazione, è necessaria una clausola del frame esplicita. La clausola frame raffina l'insieme di righe in una finestra della funzione, includendo o escludendo insieme di righe nel risultato ordinato. La clausola frame è composta dalla parola chiave ROWS e dagli specificatori associati. Per informazioni, consulta [Riepilogo della sintassi della funzione finestra](Window_functions.md#Window_function_synopsis).
## Tipo restituito
Queste funzioni supportano espressioni che utilizzano tipi di AWS Clean Rooms dati primitivi. Il tipo restituito è lo stesso del tipo di dati di *expression*.
## Esempi
L'esempio seguente restituisce la capacità di posto per ciascuna posizione nella tabella VENUE, con i risultati ordinati in base alla capacità (da alta a bassa). La funzione LAST\$1VALUE viene utilizzata per selezionare il nome del luogo corrispondente all'ultima riga nel frame: in questo caso, la riga con il numero più basso di posti. I risultati sono partizionati per stato, quindi quando il valore VENUESTATE cambia, viene selezionato un nuovo ultimo valore. Il frame della finestra è illimitato, quindi lo stesso ultimo valore è selezionato per ogni riga in ogni partizione.
Per la California, `Shoreline Amphitheatre` viene restituito per ogni riga nella partizione perché ha il numero più basso di posti (`22000`).
```
select venuestate, venueseats, venuename,
last_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | last_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Shoreline Amphitheatre
CA | 69843 | Monster Park | Shoreline Amphitheatre
CA | 63026 | McAfee Coliseum | Shoreline Amphitheatre
CA | 56000 | Dodger Stadium | Shoreline Amphitheatre
CA | 45050 | Angel Stadium of Anaheim | Shoreline Amphitheatre
CA | 42445 | PETCO Park | Shoreline Amphitheatre
CA | 41503 | AT&T Park | Shoreline Amphitheatre
CA | 22000 | Shoreline Amphitheatre | Shoreline Amphitheatre
CO | 76125 | INVESCO Field | Coors Field
CO | 50445 | Coors Field | Coors Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Tropicana Field
FL | 73800 | Jacksonville Municipal Stadium | Tropicana Field
FL | 65647 | Raymond James Stadium | Tropicana Field
FL | 36048 | Tropicana Field | Tropicana Field
...
```
# Funzione finestra LEAD
La funzione finestra LEAD restituisce i valori per una riga a una data compensazione sotto (dopo) la riga corrente nella partizione.
## Sintassi
```
LEAD (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Arguments (Argomenti)
*value\$1expr*
L'espressione o colonna di destinazione su cui viene eseguita la funzione.
*offset*
Un parametro facoltativo che specifica il numero di righe sotto la riga corrente per le quali restituire i valori. La compensazione può essere un integer costante o un'espressione che valuta un integer. Se non si specifica un offset, AWS Clean Rooms viene utilizzato `1` come valore predefinito. Una compensazione di `0` indica la riga corrente.
IGNORE NULLS
Una specifica facoltativa che indica che i valori nulli AWS Clean Rooms devono essere ignorati nella determinazione della riga da utilizzare. I valori null sono inclusi se IGNORE NULLS non è elencato.
È possibile utilizzare un'espressione NVL o COALESCE per sostituire i valori null con un altro valore.
RESPECT NULLS
Indica che AWS Clean Rooms deve includere valori nulli nella determinazione della riga da utilizzare. RESPECT NULLS è supportato come impostazione predefinita se non si specifica IGNORE NULLS.
OVER
Specifica il partizionamento e l'ordinamento della finestra. La clausola OVER non può contenere una specifica del frame della finestra.
PARTITION BY *window\$1partition*
Un argomento facoltativo che imposta l'intervallo di registrazioni per ciascun gruppo nella clausola OVER.
ORDER BY *window\$1ordering*
Ordina le righe all'interno di ogni partizione.
La funzione della finestra LEAD supporta espressioni che utilizzano qualsiasi tipo di AWS Clean Rooms dati. Il tipo di restituzione è lo stesso del tipo di dati di *value\$1expr*.
## Esempi
L'esempio seguente fornisce la commissione per gli eventi nella tabella SALES per cui i biglietti sono stati venduti il 1° gennaio 2008 e il 2 gennaio 2008 e la commissione pagata per le vendite dei biglietti per la vendita successiva.
```
select eventid, commission, saletime,
lead(commission, 1) over (order by saletime) as next_comm
from sales where saletime between '2008-01-01 00:00:00' and '2008-01-02 12:59:59'
order by saletime;
eventid | commission | saletime | next_comm
---------+------------+---------------------+-----------
6213 | 52.05 | 2008-01-01 01:00:19 | 106.20
7003 | 106.20 | 2008-01-01 02:30:52 | 103.20
8762 | 103.20 | 2008-01-01 03:50:02 | 70.80
1150 | 70.80 | 2008-01-01 06:06:57 | 50.55
1749 | 50.55 | 2008-01-01 07:05:02 | 125.40
8649 | 125.40 | 2008-01-01 07:26:20 | 35.10
2903 | 35.10 | 2008-01-01 09:41:06 | 259.50
6605 | 259.50 | 2008-01-01 12:50:55 | 628.80
6870 | 628.80 | 2008-01-01 12:59:34 | 74.10
6977 | 74.10 | 2008-01-02 01:11:16 | 13.50
4650 | 13.50 | 2008-01-02 01:40:59 | 26.55
4515 | 26.55 | 2008-01-02 01:52:35 | 22.80
5465 | 22.80 | 2008-01-02 02:28:01 | 45.60
5465 | 45.60 | 2008-01-02 02:28:02 | 53.10
7003 | 53.10 | 2008-01-02 02:31:12 | 70.35
4124 | 70.35 | 2008-01-02 03:12:50 | 36.15
1673 | 36.15 | 2008-01-02 03:15:00 | 1300.80
...
(39 rows)
```
# Funzione finestra PERCENT\$1RANK
Calcola la classificazione percentuale di una data riga. La classificazione percentuale è determinata utilizzando questa formula:
`(x - 1) / (the number of rows in the window or partition - 1)`
laddove *x* è la classificazione della riga corrente. Il seguente insieme di dati dimostra l'uso di questa formula:
```
Row# Value Rank Calculation PERCENT_RANK
1 15 1 (1-1)/(7-1) 0.0000
2 20 2 (2-1)/(7-1) 0.1666
3 20 2 (2-1)/(7-1) 0.1666
4 20 2 (2-1)/(7-1) 0.1666
5 30 5 (5-1)/(7-1) 0.6666
6 30 5 (5-1)/(7-1) 0.6666
7 40 7 (7-1)/(7-1) 1.0000
```
L'intervallo del valore di restituzione è compreso tra 0 e 1, con questi valori compresi. La prima riga in qualsiasi insieme ha un PERCENT\$1RANK di 0.
## Sintassi
```
PERCENT_RANK ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Arguments (Argomenti)
( )
La funzione non accetta argomenti, ma le parentesi vuote sono obbligatorie.
OVER
Una clausola che specifica il partizionamento della finestra. La clausola OVER non può contenere una specifica del frame della finestra.
PARTITION BY *partition\$1expression*
Opzionale. Un'espressione che imposta l'intervallo di registrazioni per ciascun gruppo nella clausola OVER.
ORDER BY *order\$1list*
Opzionale. L'espressione su cui calcolare la classificazione percentuale. L'espressione deve avere o un tipo di dati numerici o essere implicitamente convertibile in uno. Se ORDER BY viene omesso, il valore di restituzione è 0 per tutte le righe.
Se ORDER BY non produce un ordinamento univoco, l'ordine delle righe non è deterministico. Per ulteriori informazioni, consulta [Ordinamento univoco dei dati per le funzioni finestra](Window_functions.md#Examples_order_by_WF).
## Tipo restituito
FLOAT8
## Esempi
L'esempio seguente calcola la classificazione in percentuale delle quantità di vendita per ciascun venditore:
```
select sellerid, qty, percent_rank()
over (partition by sellerid order by qty)
from winsales;
sellerid qty percent_rank
----------------------------------------
1 10.00 0.0
1 10.64 0.5
1 30.37 1.0
3 10.04 0.0
3 15.15 0.33
3 20.75 0.67
3 30.55 1.0
2 20.09 0.0
2 20.12 1.0
4 10.12 0.0
4 40.23 1.0
```
Per una descrizione della tabella WINSALES, consultare [Tabella di esempio per gli esempi della funzione finestra](Window_functions.md#Window_function_example).
# Funzione finestra RANK
La funzione finestra RANK determina la classificazione di un valore in un gruppo di valori, in base all'espressione ORDER BY nella clausola OVER. Se è presente la clausola PARTITION BY facoltativa, le classificazioni vengono ripristinate per ciascun gruppo di righe. Le righe con valori uguali per i criteri di classificazione ricevono lo stesso rango. AWS Clean Roomsaggiunge il numero di righe legate alla classifica pareggiata per calcolare la classifica successiva e quindi i ranghi potrebbero non essere numeri consecutivi. Ad esempio, se due righe sono classificate come 1, il livello successivo è 3.
RANK è diverso dalla [Funzione finestra DENSE\$1RANK](WF_DENSE_RANK.md) per un aspetto: Per DENSE\$1RANK, se due o più righe si legano, non c'è spazio nella sequenza dei valori classificati. Ad esempio, se due righe sono classificate come 1, il livello successivo è 2.
È possibile avere funzioni di classificazione con diverse clausole PARTITION BY e ORDER BY nella stessa query.
## Sintassi
```
RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Arguments (Argomenti)
( )
La funzione non accetta argomenti, ma le parentesi vuote sono obbligatorie.
OVER
Le clausole finestra per la funzione RANK.
PARTITION BY *expr\$1list*
Opzionale. Una o più espressioni che definiscono la finestra.
ORDER BY *order\$1list*
Opzionale. Definisce le colonne su cui si basano i valori di classificazione. Se non viene specificato nessun PARTITION BY, ORDER BY utilizza l'intera tabella. Se ORDER BY viene omesso, il valore di restituzione è 1 per tutte le righe.
Se ORDER BY non produce un ordinamento univoco, l'ordine delle righe non è deterministico. Per ulteriori informazioni, consulta [Ordinamento univoco dei dati per le funzioni finestra](Window_functions.md#Examples_order_by_WF).
## Tipo restituito
INTEGER
## Esempi
Nel seguente esempio la tabella viene ordinata in base alla quantità venduta (in ordine crescente per impostazione predefinita) e viene assegnata una classificazione a ciascuna riga. Un valore di classificazione pari a 1 è il valore di classificazione più alto. I risultati vengono ordinati dopo aver applicato i risultati della funzione finestra:
```
select salesid, qty,
rank() over (order by qty) as rnk
from winsales
order by 2,1;
salesid | qty | rnk
--------+-----+-----
10001 | 10 | 1
10006 | 10 | 1
30001 | 10 | 1
40005 | 10 | 1
30003 | 15 | 5
20001 | 20 | 6
20002 | 20 | 6
30004 | 20 | 6
10005 | 30 | 9
30007 | 30 | 9
40001 | 40 | 11
(11 rows)
```
Si noti che la clausola ORDER BY esterna in questo esempio include le colonne 2 e 1 per garantire che vengano AWS Clean Rooms restituiti risultati ordinati in modo coerente ogni volta che viene eseguita questa query. Ad esempio, le righe con vendite IDs 10001 e 10006 hanno valori QTY e RNK identici. Ordinare il risultato finale impostato in base alla colonna 1 assicura che la riga 10001 cada sempre prima di 10006. Per una descrizione della tabella WINSALES, consultare [Tabella di esempio per gli esempi della funzione finestra](Window_functions.md#Window_function_example).
Nel seguente esempio, l'ordinamento è invertito per la funzione finestra (`order by qty desc`). Ora il valore di classificazione più alto si applica al valore QTY più alto.
```
select salesid, qty,
rank() over (order by qty desc) as rank
from winsales
order by 2,1;
salesid | qty | rank
---------+-----+-----
10001 | 10 | 8
10006 | 10 | 8
30001 | 10 | 8
40005 | 10 | 8
30003 | 15 | 7
20001 | 20 | 4
20002 | 20 | 4
30004 | 20 | 4
10005 | 30 | 2
30007 | 30 | 2
40001 | 40 | 1
(11 rows)
```
Per una descrizione della tabella WINSALES, consultare [Tabella di esempio per gli esempi della funzione finestra](Window_functions.md#Window_function_example).
Nel seguente esempio la tabella viene partizionata per SELLERID, ciascuna partizione viene ordinata in base alla quantità (in ordine decrescente) e viene assegnata una classificazione a ciascuna riga. I risultati vengono ordinati dopo aver applicato i risultati della funzione finestra.
```
select salesid, sellerid, qty, rank() over
(partition by sellerid
order by qty desc) as rank
from winsales
order by 2,3,1;
salesid | sellerid | qty | rank
--------+----------+-----+-----
10001 | 1 | 10 | 2
10006 | 1 | 10 | 2
10005 | 1 | 30 | 1
20001 | 2 | 20 | 1
20002 | 2 | 20 | 1
30001 | 3 | 10 | 4
30003 | 3 | 15 | 3
30004 | 3 | 20 | 2
30007 | 3 | 30 | 1
40005 | 4 | 10 | 2
40001 | 4 | 40 | 1
(11 rows)
```
# Funzione finestra ROW\$1NUMBER
Determina il numero ordinale di una riga corrente in un gruppo di righe, contando da 1, in base all'espressione ORDER BY nella clausola OVER. Se è presente la clausola PARTITION BY facoltativa, i numeri ordinali vengono ripristinati per ciascun gruppo di righe. Le righe con valori uguali per le espressioni ORDER BY ricevono i numeri di riga diversi in modo non deterministico.
## Sintassi
```
ROW_NUMBER () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Arguments (Argomenti)
( )
La funzione non accetta argomenti, ma le parentesi vuote sono obbligatorie.
OVER
Le clausole finestra per la funzione ROW\$1NUMBER.
PARTITION BY *expr\$1list*
Opzionale. Una o più espressioni che definiscono la funzione ROW\$1NUMBER.
ORDER BY *order\$1list*
Opzionale. L'espressione che definisce le colonne su cui si basano i numeri di riga. Se non viene specificato nessun PARTITION BY, ORDER BY utilizza l'intera tabella.
Se ORDER BY non produce un ordinamento univoco o viene omesso, l'ordine delle righe non è deterministico. Per ulteriori informazioni, consulta [Ordinamento univoco dei dati per le funzioni finestra](Window_functions.md#Examples_order_by_WF).
## Tipo restituito
BIGINT
## Esempi
L'esempio seguente esegue la partizione della tabella in SELLERID e ordina ciascuna partizione in base a QTY (in ordine crescente), quindi assegna un numero di riga a ogni riga. I risultati vengono ordinati dopo aver applicato i risultati della funzione finestra.
```
select salesid, sellerid, qty,
row_number() over
(partition by sellerid
order by qty asc) as row
from winsales
order by 2,4;
salesid | sellerid | qty | row
---------+----------+-----+-----
10006 | 1 | 10 | 1
10001 | 1 | 10 | 2
10005 | 1 | 30 | 3
20001 | 2 | 20 | 1
20002 | 2 | 20 | 2
30001 | 3 | 10 | 1
30003 | 3 | 15 | 2
30004 | 3 | 20 | 3
30007 | 3 | 30 | 4
40005 | 4 | 10 | 1
40001 | 4 | 40 | 2
(11 rows)
```
Per una descrizione della tabella WINSALES, consultare [Tabella di esempio per gli esempi della funzione finestra](Window_functions.md#Window_function_example).