Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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à.
# Funzione PERCENTILE\_CONT
PERCENTILE\_CONT è una funzione di distribuzione inversa che presuppone un modello di distribuzione continua. Prende un valore percentile e una specifica di ordinamento e restituisce un valore interpolato che rientrerebbe nel valore percentile dato rispetto alla specifica di ordinamento.
PERCENTILE\_CONT calcola un'interpolazione lineare tra i valori dopo averli ordinati. Usando il valore percentile `(P)` e il numero di righe non null `(N)` nel gruppo di aggregazione, la funzione calcola il numero di righe dopo aver ordinato le righe secondo la specifica di ordinamento. Questo numero di riga `(RN)` è calcolato secondo la formula `RN = (1+ (P*(N-1))`. Il risultato finale della funzione di aggregazione è calcolato mediante interpolazione lineare tra i valori delle righe ai numeri di riga `CRN = CEILING(RN)` e `FRN = FLOOR(RN)`.
Il risultato finale sarà il seguente.
Se `(CRN = FRN = RN)` allora il risultato è `(value of expression from row at RN)`
Altrimenti il risultato è il seguente:
`(CRN - RN) * (value of expression for row at FRN) + (RN - FRN) * (value of expression for row at CRN)`.
## Sintassi
```
PERCENTILE_CONT(percentile)
WITHIN GROUP(ORDER BY expr)
```
## Arguments (Argomenti)
*percentile*
Costante numerica tra 0 e 1. I valori `NULL` vengono ignorati nel calcolo.
*expr*
Specificate numeri o date/time valori su cui ordinare e calcolare il percentile.
## Valori restituiti
Il tipo di restituzione è determinato dal tipo di dati dell'espressione ORDER BY nella clausola WITHIN GROUP. La seguente tabella mostra il tipo di restituzione per ciascun tipo di dati dell'espressione ORDER BY.
| Tipo di input | Tipo restituito |
| --- | --- |
| INT2, INT4, INT8, NUMERIC, DECIMAL | DECIMAL |
| FLOAT, DOUBLE | DOUBLE |
| DATE | DATE |
| TIMESTAMP | TIMESTAMP |
| TIMESTAMPTZ | TIMESTAMPTZ |
## Note per l’utilizzo
Se l'espressione ORDER BY è un tipo di dati DECIMAL definito con la precisione massima di 38 cifre, è possibile che PERCENTILE\_CONT restituirà un risultato inaccurato o un errore. Se il valore di ritorno della funzione PERCENTILE\_CONT supera le 38 cifre, il risultato viene troncato per adattarsi, il che causa una perdita della precisione. Se, durante l'interpolazione, un risultato intermedio supera la precisione massima, si verifica un'eccedenza numerica e la funzione restituisce un errore. Per evitare queste condizioni, consigliamo di utilizzare un tipo di dati con una precisione inferiore o di assegnare l'espressione ORDER BY a una precisione inferiore.
Se un'istruzione comprende più chiamate a funzioni di aggregazione basate su ordinamento (LISTAGG, PERCENTILE\_CONT o MEDIAN), devono utilizzare tutti gli stessi valori ORDER BY. Notare che MEDIAN applica un ordine implicito sul valore dell'espressione.
Ad esempio, la seguente istruzione restituisce un errore.
```
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
```
La seguente istruzione viene eseguita normalmente.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## Esempi
Gli esempi seguenti utilizzano il database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
L'esempio seguente mostra che PERCENTILE\_CONT(0.5) produce gli stessi risultati di 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 |
+----------+---------+-----------------+--------+
```
L'esempio seguente trova PERCENTILE\_CONT(0.5) e PERCENTILE\_CONT(0.75) per la quantità venduta per ogni sellerid nella tabella 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 |
+----------+--------+---------+
```
Per verificare i risultati della query precedente per il primo sellerid, utilizza l'esempio seguente.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```