Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Funzioni 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).