O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

# Função de janela DENSE\$1RANK
<a name="r_WF_DENSE_RANK"></a>

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
<a name="r_WF_DENSE_RANK-synopsis"></a>

```
DENSE_RANK() OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```

## Argumentos
<a name="r_WF_DENSE_RANK-arguments"></a>

( )   
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](c_Window_functions.md#r_Examples_order_by_WF). 

## Tipo de retorno
<a name="c_Supported_data_types_wf_dense_rank"></a>

`BIGINT`

## Exemplos
<a name="r_WF_DENSE_RANK-examples"></a>

Os exemplos a seguir usam a tabela de amostra para funções de janela. Para obter mais informações, consulte [Amostra de tabela para exemplos de funções de janela](c_Window_functions.md#r_Window_function_example).

O exemplo a seguir ordena a tabela pela quantidade vendida 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 |
+---------+-----+-------+-----+
```

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.

O exemplo a seguir particiona a tabela por sellerid, ordena cada partição pela quantidade 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 |
+---------+----------+-----+-------+
```

Para utilizar o último exemplo com sucesso, use o comando a seguir para inserir uma linha na tabela WINSALES. Essa linha tem o mesmo buyerid, sellerid e qtysold de outra linha. Isso fará com que duas linhas empatem no último exemplo e, assim, mostrará a diferença entre as funções DENSE\$1RANK e RANK.

```
INSERT INTO winsales VALUES(30009, '2/2/2003', 3, 'b', 20, NULL);
```

O exemplo a seguir particiona a tabela por buyerid e sellerid, ordena cada partição pela quantidade e atribui uma classificação densa e uma classificação regular a cada linha. Os resultados são classificados após a aplicação da função de janela. 

```
SELECT salesid, sellerid, qty, buyerid,
DENSE_RANK() OVER(PARTITION BY buyerid, sellerid ORDER BY qty DESC) AS d_rnk,
RANK() OVER (PARTITION BY buyerid, sellerid ORDER BY qty DESC) AS rnk
FROM winsales
ORDER BY rnk;

+---------+----------+-----+---------+-------+-----+
| salesid | sellerid | qty | buyerid | d_rnk | rnk |
+---------+----------+-----+---------+-------+-----+
|   20001 |        2 |  20 | b       |     1 |   1 |
|   30007 |        3 |  30 | c       |     1 |   1 |
|   10006 |        1 |  10 | c       |     1 |   1 |
|   10005 |        1 |  30 | a       |     1 |   1 |
|   20002 |        2 |  20 | c       |     1 |   1 |
|   30009 |        3 |  20 | b       |     1 |   1 |
|   40001 |        4 |  40 | a       |     1 |   1 |
|   30004 |        3 |  20 | b       |     1 |   1 |
|   10001 |        1 |  10 | c       |     1 |   1 |
|   40005 |        4 |  10 | a       |     2 |   2 |
|   30003 |        3 |  15 | b       |     2 |   3 |
|   30001 |        3 |  10 | b       |     3 |   4 |
+---------+----------+-----+---------+-------+-----+
```