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 PERCENTILE\$1CONT
<a name="r_PERCENTILE_CONT"></a>

PERCENTILE\$1CONT é uma função de distribuição inversa que assume um modelo de distribuição contínua. Ela pega um valor percentil e uma especificação de classificação e retorna um valor intercalar que cairia dentro do valor percentil fornecido em relação à especificação de classificação. 

PERCENTILE\$1CONT computa uma interpolação linear entre valores após ordená-los. Usando o valor percentil `(P)` e o número de linhas não nulas `(N)` no grupo de agregação, a função computa o número da linha após ordenar as linhas de acordo com a especificação de classificação. Esse número de linha `(RN)` é computado de acordo com a fórmula `RN = (1+ (P*(N-1))`. O resultado final da função agregada é computado por interpolação linear entre os valores das linhas nos números de linha `CRN = CEILING(RN)` e `FRN = FLOOR(RN)`. 

O resultado final será o seguinte.

Se `(CRN = FRN = RN)`, o resultado é `(value of expression from row at RN)` 

Caso contrário, o resultado é o seguinte:

`(CRN - RN) * (value of expression for row at FRN) + (RN - FRN) * (value of expression for row at CRN)`.

## Sintaxe
<a name="r_PERCENTILE_CONT-synopsis"></a>

```
PERCENTILE_CONT(percentile)
WITHIN GROUP(ORDER BY expr)
```

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

 *percentil*   
Constante numérica entre 0 e 1. Os valores `NULL` são ignorados no cálculo.

*expr*  
Especifica valores numéricos ou de data/hora para classificação e computação do percentil. 

## Retornos
<a name="r_PERCENTILE_CONT-returns"></a>

O tipo de retorno é determinado pelo tipo de dados da expressão ORDER BY na cláusula WITHIN GROUP. A tabela a seguir mostra o tipo de retorno para cada tipo de dados da expressão ORDER BY.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_PERCENTILE_CONT.html)

## Observações de uso
<a name="r_PERCENTILE_CONT-usage-notes"></a>

Se a expressão ORDER BY é um tipo de dados DECIMAL com a precisão máxima de 38 dígitos, é possível que PERCENTILE\$1CONT retorne um resultado impreciso ou um erro. Se o valor de retorno da função PERCENTILE\$1CONT excede 38 dígitos, o resultado é truncado, o que causa a perda de precisão. Se, durante a interpolação, um resultado intermediário excede a precisão máxima, um excedente numérico ocorre e função retorna um erro. Para evitar essas condições, recomendamos o uso de um tipo de dados com menor precisão ou a conversão da expressão ORDER BY para uma precisão mais baixa.

Se uma instrução inclui várias chamadas para funções agregadas baseadas em classificação (LISTAGG, PERCENTILE\$1CONT ou MEDIAN), todas devem usar os mesmos valores ORDER BY. Observe que MEDIAN aplica um order by implícito no valor da expressão. 

Por exemplo, a seguinte instrução retorna um erro. 

```
SELECT TOP 10 salesid, SUM(pricepaid), 
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales 
GROUP BY salesid, pricepaid;

An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid), 
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales 
GROUP BY salesid, pricepaid;

ERROR: within group ORDER BY clauses for aggregate functions must be the same
```

A instrução a seguir é executada com êxito. 

```
SELECT TOP 10 salesid, SUM(pricepaid), 
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales 
GROUP BY salesid, pricepaid;
```

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

Os exemplos a seguir usam o banco de dados de exemplo de TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).

O seguinte exemplo mostra que PERCENTILE\$1CONT(0.5) produz os mesmos resultados que MEDIAN. 

```
SELECT TOP 10 DISTINCT sellerid, qtysold, 
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold) 
FROM sales
GROUP BY sellerid, qtysold;

+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
|        2 |       2 |               2 |      2 |
|       26 |       1 |               1 |      1 |
|       33 |       1 |               1 |      1 |
|       38 |       1 |               1 |      1 |
|       43 |       1 |               1 |      1 |
|       48 |       2 |               2 |      2 |
|       48 |       3 |               3 |      3 |
|       77 |       4 |               4 |      4 |
|       85 |       4 |               4 |      4 |
|       95 |       2 |               2 |      2 |
+----------+---------+-----------------+--------+
```

O exemplo a seguir encontra PERCENTILE\$1CONT(0.5) e PERCENTILE\$1CONT(0.75) da quantidade vendida para cada sellerid na tabela SALES.

```
SELECT sellerid, 
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold) as pct_50,
PERCENTILE_CONT(0.75) WITHIN GROUP(ORDER BY qtysold) as pct_75
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;

+----------+--------+---------+
| sellerid | pct_50 | pct_75 |
+----------+--------+---------+
|        1 |    1.5 |    1.75 |
|        2 |      2 |    2.25 |
|        3 |      2 |       3 |
|        4 |      2 |       2 |
|        5 |      1 |     1.5 |
|        6 |      1 |       1 |
|        7 |    1.5 |    1.75 |
|        8 |      1 |       1 |
|        9 |      4 |       4 |
|       12 |      2 |    3.25 |
+----------+--------+---------+
```

Para verificar os resultados da consulta anterior para o primeiro sellerid, use o exemplo a seguir.

```
SELECT qtysold 
FROM sales 
WHERE sellerid=1;

+---------+
| qtysold |
+---------+
|       2 |
|       1 |
+---------+
```