As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Funções de janela
Usando funções da janela, é possível criar consultas analíticas empresariais de forma mais eficiente. Funções de janela operam em uma partição ou “janela” de um conjunto de resultados e retornam um valor para cada linha naquela janela. Por outro lado, funções sem janela executam seus cálculos em relação a cada linha no conjunto de resultados. Diferente de funções de grupo que agregam linhas de resultado, as funções de janela retêm todas as linhas na expressão da tabela.
Os valores retornados são calculados usando valores dos conjuntos de linhas dessa janela. Para cada linha da tabela, a janela define um conjunto de linhas que é usado para computar atributos adicionais. Um janela é definida usando uma especificação de janela (a cláusula OVER) se baseia em três conceitos principais:
+ *Particionamento da janela,* que forma grupos de linhas (cláusula PARTITION)
+ *Ordenação da janela*, que define uma ordem ou sequência de linhas dentro de cada partição (cláusula ORDER BY)
+ *Quadros da janela*, que são definidos em relação a cada linha para restringir ainda mais o conjunto de linhas (especificação de ROWS)
As funções da janela são o último conjunto de operações executadas em uma consulta, exceto pela cláusula ORDER BY final. Todas as junções e todas as cláusulas WHERE, GROUP BY e HAVING são concluídas antes do processamento das funções da janela. Portanto, as funções da janela podem aparecer somente na lista de seleção ou na cláusula ORDER BY. Você pode usar várias funções da janela em uma única consulta com diferentes cláusulas de quadro. Você também pode usar funções da janela em outras expressões escalares, tal como CASE.
## Resumo da sintaxe de funções da janela
As funções de janela seguem uma sintaxe padrão, mostrada a seguir.
```
function (expression) OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list [ frame_clause ] ] )
```
Aqui, *function* é uma das funções descritas nesta seção.
A *expr\$1list* é como indicado a seguir.
```
expression | column_name [, expr_list ]
```
A *order\$1list* é como a seguir.
```
expression | column_name [ ASC | DESC ]
[ NULLS FIRST | NULLS LAST ]
[, order_list ]
```
O *frame\$1clause* é como a seguir.
```
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 }}
```
### Argumentos
*função*
A função de janela. Para obter detalhes, consulte as descrições individuais da função.
OVER
A cláusula que define a especificação da janela. A cláusula OVER é obrigatória para funções da janela e diferencia funções da janela de outras funções SQL.
PARTITION BY *expr\$1list*
(Opcional) A cláusula PARTITION BY subdivide o conjunto de resultados em partições, bem como a cláusula GROUP BY. Se uma cláusula de partição estiver presente, a função será calculada para as linhas em cada partição. Se nenhuma cláusula de partição estiver especificada, uma única partição contém a tabela inteira e a função é computada para esta tabela completa.
As funções de classificação DENSE\$1RANK, NTILE, RANK e ROW\$1NUMBER exigem uma comparação global de todas as linhas no conjunto de resultados. Quando uma cláusula PARTITION BY é utilizada, o otimizador de consulta pode executar cada agregação em paralelo, distribuindo a workload em várias fatias de acordo com as partições. Se a cláusula PARTITION BY não estiver presente, a etapa de agregação deverá ser executada em série em uma única fatia, o que poderá ter um impacto negativo considerável na performance, sobretudo para grandes clusters.
AWS Clean Roomsnão oferece suporte a literais de string nas cláusulas PARTITION BY.
ORDER BY *order\$1list*
(Opcional) A função da janela é aplicada às linhas dentro de cada partição classificada de acordo com a especificação do pedido em ORDER BY. Esta cláusula ORDER BY é diferente e totalmente não relacionada a uma cláusula ORDER BY na *frame\$1clause*. A cláusula ORDER BY pode ser usada sem a cláusula PARTITION BY.
Para as funções de classificação, a cláusula ORDER BY identifica as medidas para os valores de classificação. Para funções de agregação, as linhas particionadas devem ser ordenadas antes que a função agregada seja computada para cada quadro. Para obter mais informações sobre os tipos de função da janela, consulte [Funções de janela](#Window_functions).
Os identificadores de coluna ou expressões que avaliam os identificadores de coluna são obrigatórios na lista de ordenação. Nem constantes ou expressões constantes podem ser usadas como substitutos para nomes de coluna.
Valores NULL são tratados como seu próprio grupo, ordenados e classificados de acordo com a opção NULLS FIRST ou NULLS LAST. Por padrão, os valores NULL são ordenados e classificados por último na ordem ASC e são ordenados e classificados primeiro na ordem DESC.
AWS Clean Roomsnão oferece suporte a literais de string nas cláusulas ORDER BY.
Se a cláusula ORDER BY for omitida, a ordem das linhas não será determinística.
Em qualquer sistema paraleloAWS Clean Rooms, como quando uma cláusula ORDER BY não produz uma ordenação exclusiva e total dos dados, a ordem das linhas não é determinística. Ou seja, se a expressão ORDER BY produzir valores duplicados (uma ordenação parcial), a ordem de retorno dessas linhas poderá variar de uma sequência AWS Clean Rooms para outra. Por sua vez, funções da janela podem retornar resultados inesperados ou inconsistentes. Para obter mais informações, consulte [Ordenação exclusiva de dados para funções da janela](#Examples_order_by_WF).
*column\$1name*
Nome de uma coluna a ser particionada por ou ordenada por.
ASC \$1 DESC
Opção que define a ordem de classificação para a expressão, da seguinte forma:
+ ASC: ascendente (por exemplo, de valores numéricos menores para maiores e de "A" a "Z" para strings de caracteres). Se nenhuma opção é especificada, os dados são classificados na ordem ascendente por padrão.
+ DESC: descendente (de valores numéricos maiores para menores; de "Z" a "A" para strings).
NULLS FIRST \$1 NULLS LAST
Opção que especifica se NULLS devem ser ordenados primeiro, antes de valores não nulos, ou por último, após valores não nulos. Por padrão, NULLs são ordenados e classificados por último na ordem ASC e ordenados e classificados primeiro na ordem DESC.
*frame\$1clause*
Para funções agregadas, a cláusula do quadro refina ainda mais o conjunto de linhas na janela de uma função ao usar ORDER BY. Ele permite que você inclua ou exclua conjuntos de linhas no resultado ordenado. A cláusula de quadro consiste na palavra-chave ROWS e nos especificadores associados.
A cláusula frame não se aplica a funções de classificação. Além disso, a cláusula frame não é necessária quando nenhuma cláusula ORDER BY é usada na cláusula OVER para uma função agregada. Se uma cláusula ORDER BY é usada para uma função agregada, uma cláusula de quadro explícita é necessária.
Quando nenhuma cláusula ORDER BY é especificada, o quadro implícito é ilimitado, equivalente a ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING.
ROWS
Especificando um deslocamento físico da linha atual especificando um deslocamento físico da linha atual.
Essa cláusula especifica as linhas na janela ou particionamento atual ao qual o valor da linha atual dever ser combinado. Ela usa os argumentos que especificam a posição da linha, que pode ser antes ou depois da linha atual. O ponto de referência para todos os quadros de janela é a linha atual. Cada linha se torna a linha atual, por sua vez, à medida que o quadro de janela avança pela partição.
O quadro pode ser um conjunto simples de linhas até e incluindo a linha atual.
```
{UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW}
```
Ou pode ser um conjunto de linhas entre dois limites.
```
BETWEEN
{ UNBOUNDED PRECEDING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
AND
{ UNBOUNDED FOLLOWING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
```
UNBOUNDED PRECEDING indica que a janela começa na primeira linha da partição; *deslocamento* PRECEDING indica que a janela começa um número de linhas equivalentes ao valor do deslocamento antes da linha atual. UNBOUNDED PRECEDING é o padrão.
CURRENT ROW indica que a janela começa ou termina na linha atual.
UNBOUNDED FOLLOWING indica que a janela termina na última linha da partição; *deslocamento* FOLLOWING indica que a janela termina um número de linhas equivalentes ao valor do deslocamento depois da linha atual.
O *offset* identifica um número físico de linhas antes ou depois da linha atual. Nesse caso, o *deslocamento* deve ser uma constante que retorna um valor numérico positivo. Por exemplo, 5 FOLLOWING termina o quadro 5 linhas após a linha atual.
Onde BETWEEN não é especificado, o quadro é limitado implicitamente pela linha atual. Por exemplo, `ROWS 5 PRECEDING` é igual a `ROWS BETWEEN 5 PRECEDING AND CURRENT ROW`. Além disso, `ROWS UNBOUNDED FOLLOWING` é igual a `ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING`.
Você não pode especificar um quadro em que o limite inicial seja maior do que o limite final. Por exemplo, você não pode especificar nenhum dos quadros a seguir.
```
between 5 following and 5 preceding
between current row and 2 preceding
between 3 following and current row
```
## Ordenação exclusiva de dados para funções da janela
Se uma cláusula ORDER BY para uma função da janela não produz uma ordem única e total dos dados, a ordem das linhas não é determinística. Se a expressão ORDER BY produzir valores duplicados (uma ordenação parcial), a ordem de retorno dessas linhas pode variar em várias execuções. Nesse caso, as funções da janela também podem retornar resultados inesperados ou inconsistentes.
Por exemplo, a consulta a seguir retorna resultados diferentes ao longo de várias execuções. Esses resultados diferentes ocorrem porque `order by dateid` não produz uma ordenação exclusiva dos dados para a função da janela 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
...
```
Nesse caso, adicionar uma segunda coluna ORDER BY à função da janela pode resolver o 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
...
```
## Funções compatíveis
AWS Clean RoomsO Spark SQL suporta dois tipos de funções de janela: agregação e classificação.
Veja a seguir as funções agregadas compatíveis:
+ [Função de janela CUME\$1DIST](WF_CUME_DIST.md)
+ [Função de janela DENSE\$1RANK](WF_DENSE_RANK.md)
+ [Função FIRST window](WF_FIRST.md)
+ [Função de janela FIRST\$1VALUE](WF_first_value.md)
+ [Função de janela LAG](WF_LAG.md)
+ [Função LAST window](WF-LAST.md)
+ [Função de janela LAST\$1VALUE](WF_last_value.md)
+ [Função de janela LEAD](WF_LEAD.md)
Veja a seguir as funções de classificação compatíveis:
+ [Função de janela DENSE\$1RANK](WF_DENSE_RANK.md)
+ [Função de janela PERCENT\$1RANK](WF_PERCENT_RANK.md)
+ [Função de janela RANK](WF_RANK.md)
+ [Função de janela ROW\$1NUMBER](WF_ROW_NUMBER.md)
## Amostra de tabela para exemplos de funções de janela
É possível encontrar exemplos de função de janela específicos com cada descrição de função. Alguns dos exemplos usam uma tabela chamada WINSALES, que contém 11 linhas, conforme mostrado na tabela a seguir.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/clean-rooms/latest/sql-reference/Window_functions.html)
# Função de janela CUME\$1DIST
Calcula a distribuição cumulativa de um valor em uma janela ou partição. Assumindo uma ordem ascendente, a distribuição cumulativa é determinada usando esta fórmula:
`count of rows with values <= x / count of rows in the window or partition`
onde *x* é igual ao valor na linha atual da coluna especificada na cláusula ORDER BY. O seguinte conjunto de dados ilustra O uso desta fórmula:
```
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
```
O intervalo de valor de retorno é >0 a 1, inclusive.
## Sintaxe
```
CUME_DIST ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Argumentos
OVER
Uma cláusula que especifica o particionamento da janela. A cláusula OVER não pode conter uma especificação de quadro da janela.
PARTITION BY *partition\$1expression*
Opcional. Uma expressão que define o intervalo de registros para cada grupo na cláusula OVER.
ORDER BY *order\$1list*
A expressão na qual calcular a distribuição cumulativa. A expressão deve ter um tipo de dados numérico ou ser implicitamente conversível para um. Se ORDER BY for omitida, o valor de retorno será 1 para todas as linhas.
Se ORDER BY não produzir uma ordem única, a ordem das linhas não é determinística. Para obter mais informações, consulte [Ordenação exclusiva de dados para funções da janela](Window_functions.md#Examples_order_by_WF).
## Tipo de retorno
FLOAT8
## Exemplos
O seguinte exemplo calcula a distribuição cumulativa da quantidade para cada vendedor:
```
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
```
Para uma descrição da tabela WINSALES, consulte [Amostra de tabela para exemplos de funções de janela](Window_functions.md#Window_function_example).
# Função de janela DENSE\$1RANK
A função de janela DENSE\$1RANK determina a classificação de um valor em um grupo de valores com base na expressão ORDER BY da cláusula OVER. Se a cláusula opcional PARTITION BY estiver presente, as classificações são redefinidas para cada grupo de linhas. Linhas com valores iguais para os critérios de classificação recebem a mesma classificação. A função DENSE\$1RANK difere de RANK em um aspecto: se duas ou mais linhas empatarem, não há uma lacuna na sequência de valores classificados. Por exemplo, se duas linhas são classificadas como 1, a classificação seguinte é 2.
Você pode ter funções de classificação com diferentes cláusulas PARTITION BY e ORDER BY na mesma consulta.
## Sintaxe
```
DENSE_RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumentos
( )
A função não aceita argumentos, mas os parênteses vazios são necessários.
OVER
As cláusulas de janela para a função DENSE\$1RANK.
PARTITION BY *expr\$1list*
Opcional. Uma ou várias expressões que definem a janela.
ORDER BY *order\$1list*
Opcional. A expressão na qual os valores de classificação se baseiam. Se nenhuma PARTITION BY for especificada, ORDER BY usa a tabela completa. Se ORDER BY for omitida, o valor de retorno será 1 para todas as linhas.
Se ORDER BY não produzir uma ordem única, a ordem das linhas não é determinística. Para obter mais informações, consulte [Ordenação exclusiva de dados para funções da janela](Window_functions.md#Examples_order_by_WF).
## Tipo de retorno
INTEGER
## Exemplos
O exemplo a seguir ordena a mesa pela quantidade vendida (em ordem decrescente) e atribui uma classificação densa e uma classificação regular a cada linha. Os resultados são classificados após a aplicação dos resultados da função de janela.
```
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)
```
Observe a diferença nas classificações atribuídas ao mesmo conjunto de linhas quando as funções DENSE\$1RANK e RANK são usadas lado a lado na mesma consulta. Para uma descrição da tabela WINSALES, consulte [Amostra de tabela para exemplos de funções de janela](Window_functions.md#Window_function_example).
O exemplo a seguir particiona a tabela por SELLERID e ordena cada partição pela quantidade (em ordem decrescente) e atribui uma classificação densa a cada linha. Os resultados são classificados após a aplicação dos resultados da função de janela.
```
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)
```
Para uma descrição da tabela WINSALES, consulte [Amostra de tabela para exemplos de funções de janela](Window_functions.md#Window_function_example).
# Função FIRST window
Dado um conjunto ordenado de linhas, FIRST retorna o valor da expressão especificada em relação à primeira linha na moldura da janela.
Para obter informações sobre como selecionar a última linha no quadro, consulte [Função LAST window](WF-LAST.md).
## Sintaxe
```
FIRST( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumentos
*expressão*
A coluna ou expressão de destino na qual a função opera.
IGNORE NULLS
Quando essa opção é usada com FIRST, a função retorna o primeiro valor no quadro que não é NULL (ou NULL se todos os valores forem NULL).
RESPECT NULLS
Indica que AWS Clean Rooms deve incluir valores nulos na determinação de qual linha usar. RESPECT NULLS é compatível por padrão se você não especificar IGNORE NULLS.
OVER
Introduz as cláusulas de janela para a função.
PARTITION BY *expr\$1list*
Define a janela para a função em termos de uma ou mais expressões.
ORDER BY *order\$1list*
Classifica as linhas dentro de cada partição. Se nenhuma cláusula PARTITION BY for especificada, ORDER BY classifica a tabela inteira. Se você especificar uma cláusula ORDER BY, você também deve especificar uma *frame\$1clause*.
Os resultados da função FIRST dependem da ordem dos dados. Os resultados são não determinísticos nos seguintes casos:
+ Quando uma cláusula ORDER BY é especificada e uma partição contém dois valores diferentes para uma expressão
+ Quando uma expressão avalia para valores diferentes que correspondem ao mesmo valor na lista ORDER BY.
*frame\$1clause*
Se uma cláusula ORDER BY é usada para uma função agregada, uma cláusula de quadro explícita é necessária. A cláusula de quadro refina o conjunto de linhas na janela de uma função, incluindo ou excluindo conjuntos de linhas no resultado ordenado. A cláusula de quadro consiste na palavra-chave ROWS e nos especificadores associados. Consulte [Resumo da sintaxe de funções da janela](Window_functions.md#Window_function_synopsis).
## Tipo de retorno
Essas funções oferecem suporte a expressões que usam tipos de AWS Clean Rooms dados primitivos. O tipo de retorno é igual ao tipo de dados da *expressão*.
## Exemplos
O seguinte exemplo retorna a capacidade de acomodação para cada local de evento da tabela VENUE com os resultados ordenados por capacidade (alta a baixa). A função FIRST é usada para selecionar o nome do local que corresponde à primeira fila no quadro: nesse caso, a fila com o maior número de assentos. Os resultados são particionados por estado, portanto quando o valor VENUESTATE muda, um novo primeiro valor é selecionado. O quadro da janela não é vinculado, portanto o mesmo primeiro valor é selecionado para cada linha em cada partição.
Para a Califórnia, `Qualcomm Stadium` tem mais alto número de assentos (`70561`), portanto esse nome é o primeiro valor para todas as linhas da partição `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
...
```
# Função de janela FIRST\$1VALUE
Considerando um conjunto de linhas ordenado, FIRST\$1VALUE retorna o valor da expressão especificada em relação à primeira linha no quadro de janela.
Para obter informações sobre como selecionar a última linha no quadro, consulte [Função de janela LAST\$1VALUE](WF_last_value.md).
## Sintaxe
```
FIRST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumentos
*expressão*
A coluna ou expressão de destino na qual a função opera.
IGNORE NULLS
Quando essa opção é usada com FIRST\$1VALUE, a função retorna o primeiro valor no quadro que não seja NULL (ou NULL se todos os valores forem NULL).
RESPECT NULLS
Indica que AWS Clean Rooms deve incluir valores nulos na determinação de qual linha usar. RESPECT NULLS é compatível por padrão se você não especificar IGNORE NULLS.
OVER
Introduz as cláusulas de janela para a função.
PARTITION BY *expr\$1list*
Define a janela para a função em termos de uma ou mais expressões.
ORDER BY *order\$1list*
Classifica as linhas dentro de cada partição. Se nenhuma cláusula PARTITION BY for especificada, ORDER BY classifica a tabela inteira. Se você especificar uma cláusula ORDER BY, você também deve especificar uma *frame\$1clause*.
Os resultados da função FIRST\$1VALUE dependem da ordem dos dados. Os resultados são não determinísticos nos seguintes casos:
+ Quando uma cláusula ORDER BY é especificada e uma partição contém dois valores diferentes para uma expressão
+ Quando uma expressão avalia para valores diferentes que correspondem ao mesmo valor na lista ORDER BY.
*frame\$1clause*
Se uma cláusula ORDER BY é usada para uma função agregada, uma cláusula de quadro explícita é necessária. A cláusula de quadro refina o conjunto de linhas na janela de uma função, incluindo ou excluindo conjuntos de linhas no resultado ordenado. A cláusula de quadro consiste na palavra-chave ROWS e nos especificadores associados. Consulte [Resumo da sintaxe de funções da janela](Window_functions.md#Window_function_synopsis).
## Tipo de retorno
Essas funções oferecem suporte a expressões que usam tipos de AWS Clean Rooms dados primitivos. O tipo de retorno é igual ao tipo de dados da *expressão*.
## Exemplos
O seguinte exemplo retorna a capacidade de acomodação para cada local de evento da tabela VENUE com os resultados ordenados por capacidade (alta a baixa). A função FIRST\$1VALUE é usada para selecionar o local de evento que corresponde à primeira linha no quadro: nesse caso, a linha com o mais alto número de assentos. Os resultados são particionados por estado, portanto quando o valor VENUESTATE muda, um novo primeiro valor é selecionado. O quadro da janela não é vinculado, portanto o mesmo primeiro valor é selecionado para cada linha em cada partição.
Para a Califórnia, `Qualcomm Stadium` tem mais alto número de assentos (`70561`), portanto esse nome é o primeiro valor para todas as linhas da partição `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
...
```
# Função de janela LAG
A função de janela LAG retorna os valores para uma linha em determinado deslocamento acima (antes) da linha atual na partição.
## Sintaxe
```
LAG (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Argumentos
*value\$1expr*
A coluna ou expressão de destino na qual a função opera.
*deslocamento*
Um parâmetro opcional que especifica o número de linhas antes da linha atual para as quais retornar valores. Este deslocamento pode ser um inteiro constante ou uma expressão que avalia para um inteiro. Se você não especificar um deslocamento, AWS Clean Rooms usa `1` como valor padrão. Um deslocamento de `0` indica a linha atual.
IGNORE NULLS
Uma especificação opcional que indica que os valores nulos AWS Clean Rooms devem ser ignorados na determinação de qual linha usar. Valores nulos são incluídos se IGNORE NULLS não for listada.
Você pode usar uma expressão NVL ou COALESCE para substituir os valores nulos por outro valor.
RESPECT NULLS
Indica que AWS Clean Rooms deve incluir valores nulos na determinação de qual linha usar. RESPECT NULLS é compatível por padrão se você não especificar IGNORE NULLS.
OVER
Especifica o particionamento e ordem da janela. A cláusula OVER não pode conter uma especificação de quadro da janela.
PARTITION BY *window\$1partition*
Um argumento ideal que define o intervalo de registros para cada grupo na cláusula OVER.
ORDER BY *window\$1ordering*
Classifica as linhas dentro de cada partição.
A função de janela LAG suporta expressões que usam qualquer um dos tipos de AWS Clean Rooms dados. O tipo de retorno é igual ao tipo de *value\$1expr*.
## Exemplos
O seguinte exemplo mostra a quantidade de ingressos vendidos para o comprador com ID de comprador 3 e a hora que o comprador 3 adquiriu os ingressos. Para comparar cada venda com venda anterior para o comprador 3, a consulta retorna a quantidade anterior vendida em cada venda. Já que não há compras antes de 1/16/2008, o primeiro valor de quantidade vendida anteriormente é nulo:
```
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)
```
# Função LAST window
Dado um conjunto ordenado de linhas, a função LAST retorna o valor da expressão em relação à última linha no quadro.
Para obter informações sobre como selecionar a primeira linha no quadro, consulte [Função FIRST window](WF_FIRST.md).
## Sintaxe
```
LAST( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumentos
*expressão*
A coluna ou expressão de destino na qual a função opera.
IGNORE NULLS
A função retorna o último valor no quadro que não seja NULL (ou NULL se todos os valores forem NULL).
RESPECT NULLS
Indica que AWS Clean Rooms deve incluir valores nulos na determinação de qual linha usar. RESPECT NULLS é compatível por padrão se você não especificar IGNORE NULLS.
OVER
Introduz as cláusulas de janela para a função.
PARTITION BY *expr\$1list*
Define a janela para a função em termos de uma ou mais expressões.
ORDER BY *order\$1list*
Classifica as linhas dentro de cada partição. Se nenhuma cláusula PARTITION BY for especificada, ORDER BY classifica a tabela inteira. Se você especificar uma cláusula ORDER BY, você também deve especificar uma *frame\$1clause*.
Os resultados dependem da ordem dos dados. Os resultados são não determinísticos nos seguintes casos:
+ Quando uma cláusula ORDER BY é especificada e uma partição contém dois valores diferentes para uma expressão
+ Quando uma expressão avalia para valores diferentes que correspondem ao mesmo valor na lista ORDER BY.
*frame\$1clause*
Se uma cláusula ORDER BY é usada para uma função agregada, uma cláusula de quadro explícita é necessária. A cláusula de quadro refina o conjunto de linhas na janela de uma função, incluindo ou excluindo conjuntos de linhas no resultado ordenado. A cláusula de quadro consiste na palavra-chave ROWS e nos especificadores associados. Consulte [Resumo da sintaxe de funções da janela](Window_functions.md#Window_function_synopsis).
## Tipo de retorno
Essas funções oferecem suporte a expressões que usam tipos de AWS Clean Rooms dados primitivos. O tipo de retorno é igual ao tipo de dados da *expressão*.
## Exemplos
O seguinte exemplo retorna a capacidade de acomodação para cada local de evento da tabela VENUE com os resultados ordenados por capacidade (alta a baixa). A função LAST é usada para selecionar o nome do local que corresponde à última linha no quadro: nesse caso, a linha com o menor número de assentos. Os resultados são particionados por estado, portanto quando o valor VENUESTATE muda, um novo último valor é selecionado. O quadro da janela não é vinculado, portanto o mesmo último valor é selecionado para cada linha em cada partição.
Para a Califórnia, `Shoreline Amphitheatre` será retornado para cada linha na partição, pois tem o menor número de assentos (`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
...
```
# Função de janela LAST\$1VALUE
Considerando um conjunto de linhas ordenadas, a função LAST\$1VALUE retorna o valor da expressão em relação à última linha no quadro.
Para obter informações sobre como selecionar a primeira linha no quadro, consulte [Função de janela FIRST\$1VALUE](WF_first_value.md).
## Sintaxe
```
LAST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Argumentos
*expressão*
A coluna ou expressão de destino na qual a função opera.
IGNORE NULLS
A função retorna o último valor no quadro que não seja NULL (ou NULL se todos os valores forem NULL).
RESPECT NULLS
Indica que AWS Clean Rooms deve incluir valores nulos na determinação de qual linha usar. RESPECT NULLS é compatível por padrão se você não especificar IGNORE NULLS.
OVER
Introduz as cláusulas de janela para a função.
PARTITION BY *expr\$1list*
Define a janela para a função em termos de uma ou mais expressões.
ORDER BY *order\$1list*
Classifica as linhas dentro de cada partição. Se nenhuma cláusula PARTITION BY for especificada, ORDER BY classifica a tabela inteira. Se você especificar uma cláusula ORDER BY, você também deve especificar uma *frame\$1clause*.
Os resultados dependem da ordem dos dados. Os resultados são não determinísticos nos seguintes casos:
+ Quando uma cláusula ORDER BY é especificada e uma partição contém dois valores diferentes para uma expressão
+ Quando uma expressão avalia para valores diferentes que correspondem ao mesmo valor na lista ORDER BY.
*frame\$1clause*
Se uma cláusula ORDER BY é usada para uma função agregada, uma cláusula de quadro explícita é necessária. A cláusula de quadro refina o conjunto de linhas na janela de uma função, incluindo ou excluindo conjuntos de linhas no resultado ordenado. A cláusula de quadro consiste na palavra-chave ROWS e nos especificadores associados. Consulte [Resumo da sintaxe de funções da janela](Window_functions.md#Window_function_synopsis).
## Tipo de retorno
Essas funções oferecem suporte a expressões que usam tipos de AWS Clean Rooms dados primitivos. O tipo de retorno é igual ao tipo de dados da *expressão*.
## Exemplos
O seguinte exemplo retorna a capacidade de acomodação para cada local de evento da tabela VENUE com os resultados ordenados por capacidade (alta a baixa). A função LAST\$1VALUE é usada para selecionar o local de evento que corresponde à última linha no quadro: nesse caso, a linha com o mais baixo número de assentos. Os resultados são particionados por estado, portanto quando o valor VENUESTATE muda, um novo último valor é selecionado. O quadro da janela não é vinculado, portanto o mesmo último valor é selecionado para cada linha em cada partição.
Para a Califórnia, `Shoreline Amphitheatre` será retornado para cada linha na partição, pois tem o menor número de assentos (`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
...
```
# Função de janela LEAD
A função de janela LEAD retorna os valores para uma linha em determinado deslocamento abaixo (depois) da linha atual na partição.
## Sintaxe
```
LEAD (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Argumentos
*value\$1expr*
A coluna ou expressão de destino na qual a função opera.
*deslocamento*
Um parâmetro opcional que especifica o número de linhas abaixo da linha atual para as quais retornar valores. Este deslocamento pode ser um inteiro constante ou uma expressão que avalia para um inteiro. Se você não especificar um deslocamento, AWS Clean Rooms usa `1` como valor padrão. Um deslocamento de `0` indica a linha atual.
IGNORE NULLS
Uma especificação opcional que indica que os valores nulos AWS Clean Rooms devem ser ignorados na determinação de qual linha usar. Valores nulos são incluídos se IGNORE NULLS não for listada.
Você pode usar uma expressão NVL ou COALESCE para substituir os valores nulos por outro valor.
RESPECT NULLS
Indica que AWS Clean Rooms deve incluir valores nulos na determinação de qual linha usar. RESPECT NULLS é compatível por padrão se você não especificar IGNORE NULLS.
OVER
Especifica o particionamento e ordem da janela. A cláusula OVER não pode conter uma especificação de quadro da janela.
PARTITION BY *window\$1partition*
Um argumento ideal que define o intervalo de registros para cada grupo na cláusula OVER.
ORDER BY *window\$1ordering*
Classifica as linhas dentro de cada partição.
A função de janela LEAD oferece suporte a expressões que usam qualquer um dos tipos de AWS Clean Rooms dados. O tipo de retorno é igual ao tipo de *value\$1expr*.
## Exemplos
O seguinte exemplo fornece a comissão para eventos na tabela SALES para os quais ingressos foram vendidos em 1º de janeiro de 2008 e 2 de janeiro de 2008, assim como a comissão paga por vendas de ingressos para a venda subsequente.
```
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)
```
# Função de janela PERCENT\$1RANK
Calcula a classificação percentual de dada linha. A classificação percentual é determinada usando esta fórmula:
`(x - 1) / (the number of rows in the window or partition - 1)`
onde *x* é a classificação da linha atual. O seguinte conjunto de dados ilustra O uso desta fórmula:
```
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
```
O intervalo de valor de retorno é 0 a 1, inclusive. A primeira linha em qualquer conjunto tem um PERCENT\$1RANK de 0.
## Sintaxe
```
PERCENT_RANK ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Argumentos
( )
A função não aceita argumentos, mas os parênteses vazios são necessários.
OVER
Uma cláusula que especifica o particionamento da janela. A cláusula OVER não pode conter uma especificação de quadro da janela.
PARTITION BY *partition\$1expression*
Opcional. Uma expressão que define o intervalo de registros para cada grupo na cláusula OVER.
ORDER BY *order\$1list*
Opcional. A expressão na qual calcular a classificação percentual. A expressão deve ter um tipo de dados numérico ou ser implicitamente conversível para um. Se ORDER BY for omitida, o valor de retorno será 0 para todas as linhas.
Se ORDER BY não produzir uma ordenação exclusiva, a ordem das linhas será não determinística. Para obter mais informações, consulte [Ordenação exclusiva de dados para funções da janela](Window_functions.md#Examples_order_by_WF).
## Tipo de retorno
FLOAT8
## Exemplos
O seguinte exemplo calcula a classificação percentual das quantidades de vendas para cada vendedor:
```
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
```
Para uma descrição da tabela WINSALES, consulte [Amostra de tabela para exemplos de funções de janela](Window_functions.md#Window_function_example).
# Função de janela RANK
A função de janela RANK determina a classificação de um valor em um grupo de valores com base na expressão ORDER BY da cláusula OVER. Se a cláusula opcional PARTITION BY estiver presente, as classificações são redefinidas para cada grupo de linhas. As linhas com valores iguais para os critérios de classificação recebem a mesma classificação. AWS Clean Roomsadiciona o número de linhas empatadas à classificação empatada para calcular a próxima classificação e, portanto, as classificações podem não ser números consecutivos. Por exemplo, se duas linhas são classificadas como 1, a classificação seguinte é 3.
RANK difere de [Função de janela DENSE\$1RANK](WF_DENSE_RANK.md) em um aspecto: para DENSE\$1RANK, se duas ou mais linhas empatarem, não há uma lacuna na sequência de valores classificados. Por exemplo, se duas linhas são classificadas como 1, a classificação seguinte é 2.
Você pode ter funções de classificação com diferentes cláusulas PARTITION BY e ORDER BY na mesma consulta.
## Sintaxe
```
RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumentos
( )
A função não aceita argumentos, mas os parênteses vazios são necessários.
OVER
As cláusulas de janela para a função RANK.
PARTITION BY *expr\$1list*
Opcional. Uma ou várias expressões que definem a janela.
ORDER BY *order\$1list*
Opcional. Define as colunas nas quais os valores de classificação se baseiam. Se nenhuma PARTITION BY for especificada, ORDER BY usa a tabela completa. Se ORDER BY for omitida, o valor de retorno será 1 para todas as linhas.
Se ORDER BY não produzir uma ordenação exclusiva, a ordem das linhas será não determinística. Para obter mais informações, consulte [Ordenação exclusiva de dados para funções da janela](Window_functions.md#Examples_order_by_WF).
## Tipo de retorno
INTEGER
## Exemplos
O exemplo a seguir ordena a tabela pela quantidade vendida (padrão crescente) e atribui uma classificação a cada linha. O valor de classificação de 1 é o valor de classificação mais alto. Os resultados são classificados após a aplicação dos resultados da função de janela:
```
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)
```
Observe que a cláusula ORDER BY externa neste exemplo inclui as colunas 2 e 1 para garantir que AWS Clean Rooms retorne resultados classificados de forma consistente sempre que essa consulta for executada. Por exemplo, linhas com vendas IDs 10001 e 10006 têm valores idênticos de QTY e RNK. Ordenar o conjunto de resultados final pela coluna 1 garante que a linha 10.001 sempre caia antes de 10.006. Para uma descrição da tabela WINSALES, consulte [Amostra de tabela para exemplos de funções de janela](Window_functions.md#Window_function_example).
No exemplo a seguir, a ordenação é revertida para a função da janela (`order by qty desc`). Agora, o valor de classificação mais alto se aplica ao valor de QTY mais 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)
```
Para uma descrição da tabela WINSALES, consulte [Amostra de tabela para exemplos de funções de janela](Window_functions.md#Window_function_example).
O exemplo a seguir particiona a tabela por SELLERID e ordena cada partição pela quantidade (em ordem decrescente) e atribui uma classificação a cada linha. Os resultados são classificados após a aplicação dos resultados da função de janela.
```
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)
```
# Função de janela ROW\$1NUMBER
Determina o número ordinal da linha atual em um grupo de linhas, começando com 1, com base na expressão ORDER BY da cláusula OVER. Se a cláusula opcional PARTITION BY estiver presente, os números ordinais são redefinidos para cada grupo de linhas. As linhas com valores iguais para as expressões ORDER BY recebem os diferentes números de linha de forma não determinística.
## Sintaxe
```
ROW_NUMBER () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Argumentos
( )
A função não aceita argumentos, mas os parênteses vazios são necessários.
OVER
As cláusulas de janela para a função ROW\$1NUMBER.
PARTITION BY *expr\$1list*
Opcional. Uma ou mais expressões que definem a função ROW\$1NUMBER.
ORDER BY *order\$1list*
Opcional. A expressão que define as colunas nas quais os números de linha se baseiam. Se nenhuma PARTITION BY for especificada, ORDER BY usa a tabela completa.
Se ORDER BY não produzir uma ordenação exclusiva ou for omitido, a ordem das linhas será não determinística. Para obter mais informações, consulte [Ordenação exclusiva de dados para funções da janela](Window_functions.md#Examples_order_by_WF).
## Tipo de retorno
BIGINT
## Exemplos
O seguinte exemplo particiona a tabela por SELLERID e ordena cada partição por QTY (na ordem ascendente) e, então, atribui um número de linha para cada linha. Os resultados são classificados após a aplicação dos resultados da função de janela.
```
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)
```
Para uma descrição da tabela WINSALES, consulte [Amostra de tabela para exemplos de funções de janela](Window_functions.md#Window_function_example).