Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Fonction PERCENTILE\$1CONT
La fonction PERCENTILE\$1CONT est une fonction de distribution inverse qui suppose un modèle de distribution continue. Elle prend une valeur de centile et une spécification de tri, et renvoie une valeur interpolée qui entre dans la catégorie de la valeur de centile donnée en ce qui concerne la spécification de tri.
PERCENTILE\$1CONT calcule une interpolation linéaire entre les valeurs après les avoir ordonnées. A l’aide de la valeur de centile `(P)` et le nombre de lignes non null `(N)` dans le groupe d’agrégation, la fonction calcule le nombre de lignes après l’ordonnancement des lignes en fonction de la spécification de tri. Ce nombre de lignes `(RN)` est calculé selon la formule `RN = (1+ (P*(N-1))`. Le résultat de la fonction d’agrégation est calculé par interpolation linéaire entre les valeurs des lignes aux numéros de ligne `CRN = CEILING(RN)` et `FRN = FLOOR(RN)`.
Le résultat final sera le suivant.
Si `(CRN = FRN = RN)` le résultat est `(value of expression from row at RN)`
Sinon, le résultat est le suivant :
`(CRN - RN) * (value of expression for row at FRN) + (RN - FRN) * (value of expression for row at CRN)`.
## Syntaxe
```
PERCENTILE_CONT(percentile)
WITHIN GROUP(ORDER BY expr)
```
## Arguments
*percentile*
Constante numérique comprise entre 0 et 1. Les valeurs `NULL` sont ignorées dans le calcul.
*expr*
Spécifie date/time les valeurs numériques ou sur lesquelles trier et calculer le percentile.
## Renvoie
Le type de retour est déterminé par le type de données de l’expression ORDER BY dans la clause WITHIN GROUP. Le tableau suivant illustre le type de retour de chaque type de données d’expression ORDER BY.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PERCENTILE_CONT.html)
## Notes d’utilisation
Si l’expression ORDER BY est un type de données DECIMAL défini avec la précision maximale de 38 chiffres, il est possible que PERCENTILE\$1CONT renvoie un résultat inexact ou une erreur. Si la valeur de retour de la fonction PERCENTILE\$1CONT dépasse 38 chiffres, le résultat est tronqué pour s’adapter, ce qui entraîne une perte de précision.. Si, au cours de l’interpolation, un résultat intermédiaire dépasse la précision maximale, un dépassement de capacité numérique se produit et la fonction renvoie une erreur. Pour éviter ces conditions, nous vous recommandons d’utiliser un type de données avec une précision inférieure ou l’expression ORDER BY avec une précision inférieure.
Si une instruction inclut plusieurs appels à des fonctions d’agrégation basées sur le tri (LISTAGG, PERCENTILE\$1CONT, or MEDIAN), elles doivent toutes utiliser les mêmes valeurs ORDER BY. Notez que MEDIAN applique une clause order by implicite sur la valeur d’expression.
Par exemple, l’instruction suivante renvoie une erreur.
```
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
```
L’instruction suivante s’exécute avec succès.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## Exemples
Les exemples suivants utilisent l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
L’exemple suivant montre que PERCENTILE\$1CONT(0.5) produit les mêmes résultats 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 |
+----------+---------+-----------------+--------+
```
L’exemple suivant recherche PERCENTILE\$1CONT(0.5) et PERCENTILE\$1CONT(0.75) pour la quantité vendue pour chaque ID de vendeur dans la table 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 |
+----------+--------+---------+
```
Pour vérifier les résultats de la requête précédente pour le premier ID de vendeur, utilisez l’exemple suivant.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```