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.
# Fonctions d’agrégation
**Topics**
+ [Fonction ANY\$1VALUE](r_ANY_VALUE.md)
+ [Fonction APPROXIMATE PERCENTILE\$1DISC](r_APPROXIMATE_PERCENTILE_DISC.md)
+ [Fonction AVG](r_AVG.md)
+ [Fonction COUNT](r_COUNT.md)
+ [Fonction LISTAGG](r_LISTAGG.md)
+ [Fonction MAX](r_MAX.md)
+ [Fonction MEDIAN](r_MEDIAN.md)
+ [Fonction MIN](r_MIN.md)
+ [Fonction PERCENTILE\$1CONT](r_PERCENTILE_CONT.md)
+ [Fonctions STDDEV\$1SAMP et STDDEV\$1POP](r_STDDEV_functions.md)
+ [Fonction SUM](r_SUM.md)
+ [Fonctions VAR\$1SAMP et VAR\$1POP](r_VARIANCE_functions.md)
Les fonctions d’agrégation calculent une valeur de résultat unique à partir d’un ensemble de valeurs d’entrée.
Les instructions SELECT utilisant des fonctions d’agrégation peuvent inclure deux clauses facultatives : GROUP BY et HAVING. La syntaxe de ces clauses est la suivante (avec la fonction COUNT par exemple) :
```
SELECT count (*) expression FROM table_reference
WHERE condition [GROUP BY expression ] [ HAVING condition]
```
La clause GROUP BY agrège et regroupe les résultats en fonction de valeurs uniques dans une ou des colonnes spécifiées. La clause HAVING limite les résultats renvoyés aux lignes dans lesquelles une condition d’agrégation particulière a la valeur true, par exemple count (\$1) > 1. La clause HAVING est utilisée de la même manière que WHERE afin de limiter les lignes en fonction de la valeur d’une colonne. Pour voir un exemple de ces clauses supplémentaires, consultez [COUNT](r_COUNT.md).
Les fonctions d’agrégation n’acceptent pas les fonctions d’agrégation ou les fonctions de fenêtrage imbriquées comme arguments.
# Fonction ANY\$1VALUE
La fonction ANY\$1VALUE renvoie n’importe quelle valeur des valeurs d’expression en entrée de manière non déterministe. Cette fonction renvoie la valeur `NULL` si l’expression en entrée n’entraîne pas de renvoi de ligne. La fonction peut également renvoyer `NULL` si l’expression d’entrée contient des valeurs `NULL`. Si l’entrée contient des valeurs `NULL` mélangées à des valeurs autres que `NULL`, `NULL` peut être renvoyé. Si toutes les valeurs sont `NULL`, `NULL` est renvoyé. Si aucune ligne ne correspond à la condition, `NULL` est renvoyé.
## Syntaxe
```
ANY_VALUE( [ DISTINCT | ALL ] expression )
```
## Arguments
DISTINCT \$1 ALL
Spécifiez DISTINCT ou ALL pour renvoyer n’importe quelle valeur des valeurs d’expression en entrée. L’argument DISTINCT n’a aucun effet et est ignoré.
*expression*
Colonne cible ou expression sur laquelle la fonction opère. L’*expression* est l’un des types de données suivants :
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ BOOLEAN
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ INTERVAL YEAR TO MONTH
+ INTERVAL DAY TO SECOND
+ VARBYTE
+ SUPER
+ HLLSKETCH
+ GEOMETRY
+ GEOGRAPHY
## Renvoie
Renvoie le même type de données que *expression*.
## Notes d’utilisation
Si une instruction qui spécifie la fonction ANY\$1VALUE d’une colonne inclut également une deuxième référence de colonne, la deuxième colonne doit apparaître dans une clause GROUP BY ou être incluse dans une fonction d’agrégation.
## Exemples
Les exemples utilisent la table d’événements créée à l’[étape 4 : charger des exemples de données depuis Amazon S3](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) du *Guide de démarrage d’Amazon Redshift*. L’exemple suivant renvoie une instance de n’importe quel dateid dont le nom d’événement est Eagles.
```
select any_value(dateid) as dateid, eventname from event where eventname ='Eagles' group by eventname;
```
Voici les résultats.
```
dateid | eventname
-------+---------------
1878 | Eagles
```
L’exemple suivant renvoie une instance de n’importe quel dateid dont le nom d’événement est Eagles ou Cold War Kids.
```
select any_value(dateid) as dateid, eventname from event where eventname in('Eagles', 'Cold War Kids') group by eventname;
```
Voici les résultats.
```
dateid | eventname
-------+---------------
1922 | Cold War Kids
1878 | Eagles
```
# Fonction APPROXIMATE PERCENTILE\$1DISC
APPROXIMATE PERCENTILE\$1DISC est une fonction de distribution inverse qui suppose un modèle de distribution discrète. Elle prend une valeur de centile et une spécification de tri et renvoie un élément de l’ensemble donné. L’approximation permet une exécution de la fonction nettement plus rapide, avec une erreur relative faible d’environ 0,5 %.
Pour une valeur de *percentile* donnée, APPROXIMATE PERCENTILE\$1DISC utilise un algorithme résumé de quantile afin d’évaluer de façon approximative le percentile discret de l’expression dans la clause ORDER BY. APPROXIMATE PERCENTILE\$1DISC renvoie la valeur ayant la valeur de distribution cumulative la moins élevée (par rapport à la même spécification de tri) supérieure ou égale au *percentile*.
## Syntaxe
```
APPROXIMATE PERCENTILE_DISC ( 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.
WITHIN GROUP ( ORDER BY *expr*)
Clause qui spécifie les date/time valeurs numériques ou sur lesquelles trier et calculer le percentile.
## Renvoie
Type de données identique à l’expression ORDER BY dans la clause WITHIN GROUP.
## Notes d’utilisation
Si l’instruction APPROXIMATE PERCENTILE\$1DISC inclut une clause GROUP BY, le jeu de résultats est limité. La limite varie en fonction du type de nœud et du nombre de nœuds. Si la limite est dépassée, la fonction échoue et renvoie l’erreur suivante.
```
GROUP BY limit for approximate percentile_disc exceeded.
```
Si vous devez évaluer plus de groupes que ne le permet la limite, pensez à utiliser [Fonction PERCENTILE\$1CONT](r_PERCENTILE_CONT.md).
## Exemples
L’exemple suivant renvoie le nombre de ventes, le total des ventes et la valeur du 50e percentile pour les 10 meilleures dates.
```
select top 10 date.caldate,
count(totalprice), sum(totalprice),
approximate percentile_disc(0.5)
within group (order by totalprice)
from listing
join date on listing.dateid = date.dateid
group by date.caldate
order by 3 desc;
caldate | count | sum | percentile_disc
-----------+-------+------------+----------------
2008-01-07 | 658 | 2081400.00 | 2020.00
2008-01-02 | 614 | 2064840.00 | 2178.00
2008-07-22 | 593 | 1994256.00 | 2214.00
2008-01-26 | 595 | 1993188.00 | 2272.00
2008-02-24 | 655 | 1975345.00 | 2070.00
2008-02-04 | 616 | 1972491.00 | 1995.00
2008-02-14 | 628 | 1971759.00 | 2184.00
2008-09-01 | 600 | 1944976.00 | 2100.00
2008-07-29 | 597 | 1944488.00 | 2106.00
2008-07-23 | 592 | 1943265.00 | 1974.00
```
# Fonction AVG
La fonction AVG renvoie la moyenne (arithmétique) des valeurs d’expression d’entrée. La fonction AVG utilise des valeurs numériques et ignore les valeurs NULL.
## Syntaxe
```
AVG ( [ DISTINCT | ALL ] expression )
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère. L’*expression* est l’un des types de données suivants :
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ SUPER
DISTINCT \$1 ALL
Avec l’argument DISTINCT, la fonction supprime toutes les valeurs en double dans l’expression spécifiée avant de calculer la moyenne. Avec l’argument ALL, la fonction conserve toutes les valeurs en double de l’expression pour calculer la moyenne. La valeur par défaut est ALL.
## Types de données
Les types d’argument pris en charge par la fonction AVG sont SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION et SUPER.
Les types de retour pris en charge par la fonction AVG sont les suivants :
+ BIGINT pour tout argument de type nombre entier
+ DOUBLE PRECISION pour un argument à virgule flottante
+ Renvoie le même type de données que l’expression pour tout autre type d’argument.
La précision par défaut d’un résultat de fonction AVG avec un argument NUMERIC ou DECIMAL est de 38. L’échelle du résultat est identique à celle de l’argument. Par exemple, une fonction AVG d’une colonne DEC(5,2) renvoie un type de données DEC(38,2).
## Exemples
Recherchez la quantité moyenne vendue par transaction dans la table SALES :
```
select avg(qtysold)from sales;
avg
-----
2
(1 row)
```
Recherchez le prix total moyen répertorié dans toutes les listes :
```
select avg(numtickets*priceperticket) as avg_total_price from listing;
avg_total_price
-----------------
3034.41
(1 row)
```
Recherchez le prix moyen payé, regroupé par mois par ordre décroissant :
```
select avg(pricepaid) as avg_price, month
from sales, date
where sales.dateid = date.dateid
group by month
order by avg_price desc;
avg_price | month
-----------+-------
659.34 | MAR
655.06 | APR
645.82 | JAN
643.10 | MAY
642.72 | JUN
642.37 | SEP
640.72 | OCT
640.57 | DEC
635.34 | JUL
635.24 | FEB
634.24 | NOV
632.78 | AUG
(12 rows)
```
# Fonction COUNT
La fonction COUNT compte les lignes définies par l’expression.
La fonction COUNT présente les variantes suivantes.
+ COUNT (\$1) compte toutes les lignes de la table cible, qu’elles comprennent des valeurs null ou non.
+ COUNT ( *expression* ) calcule le nombre de lignes avec des valeurs non NULL dans une colonne ou une expression spécifique.
+ COUNT ( DISTINCT *expression* ) calcule le nombre de valeurs non NULL distinctes dans une colonne ou une expression.
+ APPROXIMATE COUNT DISTINCT donne une approximation du nombre de valeurs distinctes non NULL dans une colonne ou une expression.
## Syntaxe
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] expression )
```
```
APPROXIMATE COUNT ( DISTINCT expression )
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère. La fonction COUNT prend en charge tous les types de données d’argument.
DISTINCT \$1 ALL
Avec l’argument DISTINCT, la fonction supprime toutes les valeurs en double dans l’expression spécifiée avant d’effectuer le compte. Avec l’argument ALL, la fonction conserve toutes les valeurs en double de l’expression pour le compte. La valeur par défaut est ALL.
APPROXIMATE
Lorsqu'elle est utilisée avec APPROXIMATE, une fonction COUNT DISTINCT utilise un HyperLogLog algorithme pour estimer le nombre de valeurs distinctes non NULL dans une colonne ou une expression. Les requêtes qui utilisent le mot clé APPROXIMATE s’exécutent beaucoup plus rapidement, avec une erreur relative faible d’environ 2 %. L’approximation est garantie pour les requêtes qui renvoient un grand nombre de valeurs distinctes (par millions ou plus encore) par requête, ou par groupe, en cas de clause GROUP BY. Pour les ensembles plus petits de valeurs distinctes (par milliers), l’approximation peut être plus lente qu’un compte précis. La fonction APPROXIMATE peut être utilisée uniquement avec COUNT DISTINCT.
## Type de retour
La fonction COUNT renvoie BIGINT.
## Exemples
Pour compter tous les utilisateurs de l’état de Floride :
```
select count(*) from users where state='FL';
count
-------
510
```
Comptez tous les noms d’événements de la table EVENT :
```
select count(eventname) from event;
count
-------
8798
```
Comptez tous les noms d’événements de la table EVENT :
```
select count(all eventname) from event;
count
-------
8798
```
Comptez tous les lieux uniques dans le tableau IDs des ÉVÉNEMENTS :
```
select count(distinct venueid) as venues from event;
venues
--------
204
```
Pour compter le nombre de fois où chaque vendeur a répertorié des lots de plus de quatre billets en vente. Pour regrouper les résultats de l’ID du vendeur :
```
select count(*), sellerid from listing
where numtickets > 4
group by sellerid
order by 1 desc, 2;
count | sellerid
------+----------
12 | 6386
11 | 17304
11 | 20123
11 | 25428
...
```
Les exemples suivants comparent les valeurs de retour et les durées d’exécution de COUNT et de APPROXIMATE COUNT.
```
select count(distinct pricepaid) from sales;
count
-------
4528
Time: 48.048 ms
select approximate count(distinct pricepaid) from sales;
count
-------
4553
Time: 21.728 ms
```
# Fonction LISTAGG
Pour chaque groupe d’une requête, la fonction d’agrégation LISTAGG trie les lignes du groupe conformément à l’expression ORDER BY, puis concatène les valeurs en une chaîne unique.
## Syntaxe
```
LISTAGG( [DISTINCT] aggregate_expression [, 'delimiter' ] )
[ WITHIN GROUP (ORDER BY order_list) ]
```
## Arguments
DISTINCT
Clause qui supprime toutes les valeurs en double dans l’expression spécifiée avant de procéder à la concaténation. Les espaces de fin sont ignorés. Par exemple, les chaînes `'a'` et `'a '` sont traitées comme des doublons. LISTAGG utilise la première valeur rencontrée. Pour plus d'informations, consultez [Signification des blancs de fin](r_Character_types.md#r_Character_types-significance-of-trailing-blanks).
*aggregate\$1expression*
Toute expression valide, comme un nom de colonne, qui fournit les valeurs à regrouper. Les valeurs NULL et les chaînes vides sont ignorées.
*delimiter*
Constante de chaîne qui sépare les valeurs concaténées. La valeur par défaut est NULL.
*WITHIN GROUP (ORDER BY order\$1list)*
Clause qui spécifie l’ordre de tri des valeurs regroupées.
## Renvoie
VARCHAR(MAX). Si le jeu de résultats est supérieur à la taille de VARCHAR maximale, LISTAGG renvoie l’erreur suivante :
```
Invalid operation: Result size exceeds LISTAGG limit
```
## Notes d’utilisation
+ Si une instruction inclut plusieurs fonctions LISTAGG qui utilisent des clauses WITHIN GROUP, chaque clause WITHIN GROUP doit utiliser les mêmes valeurs ORDER BY.
Par exemple, l’instruction suivante renvoie une erreur.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY sellerid) AS dates
FROM sales;
```
L’instruction suivante s’exécute avec succès.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY dateid) AS dates
FROM sales;
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid) AS dates
FROM sales;
```
+ Vous ne pouvez pas utiliser les fonctions d’agrégation LISTAGG, PERCENTILE\$1CONT et MEDIAN avec d’autres fonctions d’agrégation distinctes.
## Exemples
L'exemple suivant regroupe les vendeurs IDs, triés par numéro de vendeur.
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
----------------------------------------------------------------------------------------------------------------------------------------
380, 380, 1178, 1178, 1178, 2731, 8117, 12905, 32043, 32043, 32043, 32432, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 47188, 48294
```
L'exemple suivant utilise DISTINCT pour renvoyer une liste de vendeurs uniques IDs.
```
SELECT LISTAGG(DISTINCT sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
-------------------------------------------------------------------------------------------
380, 1178, 2731, 8117, 12905, 32043, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 48294
```
L'exemple suivant regroupe les vendeurs par ordre IDs chronologique.
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY dateid)
FROM sales
WHERE eventid = 4337;
listagg
-----------------------------------------------------------------------------------------------------------------------------------------
41498, 47188, 47188, 1178, 1178, 1178, 380, 45676, 46324, 48294, 32043, 32043, 32432, 12905, 8117, 38750, 2731, 32432, 32043, 380, 38669
```
L’exemple suivant renvoie une liste des dates de ventes de l’acheteur ID 660 séparées par des barres verticales.
```
SELECT LISTAGG(
(SELECT caldate FROM date WHERE date.dateid=sales.dateid), ' | '
)
WITHIN GROUP (ORDER BY sellerid DESC, salesid ASC)
FROM sales
WHERE buyerid = 660;
listagg
-------------------------------------------------
2008-07-16 | 2008-07-09 | 2008-01-01 | 2008-10-26
```
L'exemple suivant renvoie une liste des ventes séparées par des IDs virgules pour les acheteurs IDs 660, 661 et 662.
```
SELECT buyerid,
LISTAGG(salesid,', ')
WITHIN GROUP (ORDER BY salesid) AS sales_id
FROM sales
WHERE buyerid BETWEEN 660 AND 662
GROUP BY buyerid
ORDER BY buyerid;
buyerid | sales_id
--------+-----------------------------------------------------
660 | 32872, 33095, 33514, 34548
661 | 19951, 20517, 21695, 21931
662 | 3318, 3823, 4215, 51980, 53202, 55908, 57832, 171603
```
# Fonction MAX
La fonction MAX renvoie la valeur maximale d’un ensemble de lignes. La fonction DISTINCT ou ALL peut être utilisée, mais elle n’affecte pas le résultat.
## Syntaxe
```
MAX ( [ DISTINCT | ALL ] expression )
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère. L’*expression* est l’un des types de données suivants :
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
Avec l’argument DISTINCT, la fonction supprime toutes les valeurs en double dans l’expression spécifiée avant de calculer la valeur maximale. Avec l’argument ALL, la fonction conserve toutes les valeurs en double de l’expression pour calculer la valeur maximale. La valeur par défaut est ALL.
## Types de données
Renvoie le même type de données que *expression*. L’équivalent booléen de la fonction MIN est [Fonction BOOL\$1AND](r_BOOL_AND.md), et l’équivalent booléen de MAX est [Fonction BOOL\$1OR](r_BOOL_OR.md).
## Exemples
Recherchez le prix le plus élevé payé de toutes les ventes :
```
select max(pricepaid) from sales;
max
----------
12624.00
(1 row)
```
Pour trouver le prix le plus élevé payé par billet de toutes les ventes :
```
select max(pricepaid/qtysold) as max_ticket_price
from sales;
max_ticket_price
-----------------
2500.00000000
(1 row)
```
# Fonction MEDIAN
Calcule la valeur médiane de la plage de valeurs. Les valeurs `NULL` de la plage sont ignorées.
MEDIAN est une fonction de distribution inverse qui suppose un modèle de distribution continue.
MEDIAN est un cas particulier de [PERCENTILE\$1CONT](r_PERCENTILE_CONT.md).
## Syntaxe
```
MEDIAN(median_expression)
```
## Arguments
*median\$1expression*
Colonne cible ou expression sur laquelle la fonction opère.
## Types de données
Le type de retour est déterminé par le type de données de *median\$1expression*. Le tableau suivant illustre le type de retour de chaque type de données *median\$1expression*.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_MEDIAN.html)
## Notes d’utilisation
Si l’argument *median\$1expression* est un type de données `DECIMAL` défini avec la précision maximale de 38 chiffres, il est possible que MEDIAN renvoie un résultat inexact ou une erreur. Si la valeur de retour de la fonction MEDIAN 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’argument *median\$1expression* 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 MEDIAN produit les mêmes résultats que PERCENTILE\$1CONT(0.5).
```
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 permet de trouver la quantité médiane vendue pour chaque ID de vendeur.
```
SELECT sellerid,
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+
| sellerid | median |
+----------+--------+
| 1 | 1.5 |
| 2 | 2 |
| 3 | 2 |
| 4 | 2 |
| 5 | 1 |
| 6 | 1 |
| 7 | 1.5 |
| 8 | 1 |
| 9 | 4 |
| 12 | 2 |
+----------+--------+
```
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 |
+---------+
```
# Fonction MIN
La fonction MIN renvoie la valeur minimale d’un ensemble de lignes. La fonction DISTINCT ou ALL peut être utilisée, mais elle n’affecte pas le résultat.
## Syntaxe
```
MIN ( [ DISTINCT | ALL ] expression )
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère. L’*expression* est l’un des types de données suivants :
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
Avec l’argument DISTINCT, la fonction supprime toutes les valeurs en double dans l’expression spécifiée avant de calculer la valeur minimale. Avec l’argument ALL, la fonction conserve toutes les valeurs en double de l’expression pour calculer la valeur minimale. La valeur par défaut est ALL.
## Types de données
Renvoie le même type de données que *expression*. L’équivalent booléen de la fonction MIN est [Fonction BOOL\$1AND](r_BOOL_AND.md), et l’équivalent booléen de MAX est [Fonction BOOL\$1OR](r_BOOL_OR.md).
## Exemples
Pour trouver le prix le plus bas payé de toutes les ventes :
```
select min(pricepaid) from sales;
min
-------
20.00
(1 row)
```
Pour trouver le prix le plus bas payé par billet de toutes les ventes :
```
select min(pricepaid/qtysold)as min_ticket_price
from sales;
min_ticket_price
------------------
20.00000000
(1 row)
```
# 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 |
+---------+
```
# Fonctions STDDEV\$1SAMP et STDDEV\$1POP
Les fonctions STDDEV\$1SAMP et STDDEV\$1POP renvoient l’écart type entre l’échantillon et la population d’un ensemble de valeurs numériques (nombre entier, décimale ou à virgule flottante). Le résultat de la fonction STDDEV\$1SAMP est équivalent à la racine carré de la variance de l’échantillon du même ensemble de valeurs.
STDDEV\$1SAMP et STDDEV sont des synonymes de la même fonction.
## Syntaxe
```
STDDEV_SAMP | STDDEV ( [ DISTINCT | ALL ] expression)
STDDEV_POP ( [ DISTINCT | ALL ] expression)
```
L’expression doit comporter un type de données de nombre entier, décimale ou à virgule flottante. Quel que soit le type de données de l’expression, le type de retour de cette fonction est un nombre double précision.
**Note**
L’écart type est calculé à l’aide de l’arithmétique à virgule flottante, qui peut se traduire par une légère imprécision.
## Notes d’utilisation
Lorsque l’écart type de l’échantillon (STDDEV ou STDDEV\$1SAMP) est calculé pour une expression qui se compose d’une seule valeur, le résultat de la fonction est NULL, pas 0.
## Exemples
La requête suivante renvoie la moyenne des valeurs de la colonne VENUESEATS de la table VENUE, suivie par l’écart type de l’échantillon et l’écart type de la population du même ensemble de valeurs. VENUESEATS est une colonne INTEGER. L’échelle du résultat est réduite à 2 chiffres.
```
select avg(venueseats),
cast(stddev_samp(venueseats) as dec(14,2)) stddevsamp,
cast(stddev_pop(venueseats) as dec(14,2)) stddevpop
from venue;
avg | stddevsamp | stddevpop
-------+------------+-----------
17503 | 27847.76 | 27773.20
(1 row)
```
La requête suivante renvoie l’écart type de l’échantillon pour la colonne COMMISSION de la table SALES. COMMISSION est une virgule DECIMAL. L’échelle du résultat est réduite à 10 chiffres.
```
select cast(stddev(commission) as dec(18,10))
from sales;
stddev
----------------
130.3912659086
(1 row)
```
La requête suivante convertit l’écart type de l’échantillon de la colonne COMMISSION en un nombre entier.
```
select cast(stddev(commission) as integer)
from sales;
stddev
--------
130
(1 row)
```
La requête suivante renvoie l’écart type de l’échantillon et la racine carré de la variance de l’échantillon pour la colonne COMMISSION. Les résultats de ces calculs sont identiques.
```
select
cast(stddev_samp(commission) as dec(18,10)) stddevsamp,
cast(sqrt(var_samp(commission)) as dec(18,10)) sqrtvarsamp
from sales;
stddevsamp | sqrtvarsamp
----------------+----------------
130.3912659086 | 130.3912659086
(1 row)
```
# Fonction SUM
La fonction SUM renvoie la somme des valeurs de la colonne d’entrée ou de l’expression. La fonction SUM utilise des valeurs numériques et ignore les valeurs NULL.
## Syntaxe
```
SUM ( [ DISTINCT | ALL ] expression )
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère. L’*expression* est l’un des types de données suivants :
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ SUPER
DISTINCT \$1 ALL
Avec l’argument DISTINCT, la fonction supprime toutes les valeurs en double dans l’expression spécifiée avant de calculer la somme. Avec l’argument ALL, la fonction conserve toutes les valeurs en double de l’expression pour calculer la somme. La valeur par défaut est ALL.
## Types de données
Les types d’argument pris en charge par la fonction SUM sont SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION et SUPER.
Les types de retour pris en charge par la fonction SUM sont les suivants :
+ BIGINT pour les arguments BIGINT, SMALLINT et INTEGER
+ NUMERIC pour les arguments NUMERIC
+ DOUBLE PRECISION pour les arguments à virgule flottante
+ Renvoie le même type de données que l’expression pour tout autre type d’argument.
La précision par défaut d’un résultat de fonction SUM avec un argument NUMERIC ou DECIMAL est de 38. L’échelle du résultat est identique à celle de l’argument. Par exemple, une fonction SUM d’une colonne DEC(5,2) renvoie un type de données DEC(38,2).
## Exemples
Pour rechercher toutes les commissions payées à partir de la table SALES :
```
select sum(commission) from sales;
sum
-------------
16614814.65
(1 row)
```
Pour trouver le nombre de places de tous les lieux de l’état de Floride :
```
select sum(venueseats) from venue
where venuestate = 'FL';
sum
--------
250411
(1 row)
```
Pour trouver le nombre de places vendu en mai :
```
select sum(qtysold) from sales, date
where sales.dateid = date.dateid and date.month = 'MAY';
sum
-------
32291
(1 row)
```
# Fonctions VAR\$1SAMP et VAR\$1POP
Les fonctions VAR\$1SAMP et VAR\$1POP renvoient la variance entre l’échantillon et la population d’un ensemble de valeurs numériques (nombre entier, décimale ou à virgule flottante). Le résultat de la fonction VAR\$1SAMP est équivalent au carré de l’écart type de l’échantillon du même ensemble de valeurs.
VAR\$1SAMP et VARIANCE sont des synonymes de la même fonction.
## Syntaxe
```
VAR_SAMP | VARIANCE ( [ DISTINCT | ALL ] expression)
VAR_POP ( [ DISTINCT | ALL ] expression)
```
L’expression doit comporter un type de données de nombre entier, décimale ou à virgule flottante. Quel que soit le type de données de l’expression, le type de retour de cette fonction est un nombre double précision.
**Note**
Les résultats de ces fonctions peuvent varier entre les clusters d’entrepôts des données, en fonction de la configuration du cluster dans chaque cas.
## Notes d’utilisation
Lorsque l’écart type de l’échantillon (VARIANCE ou VAR\$1SAMP) est calculé pour une expression qui se compose d’une valeur unique, le résultat de la fonction est NULL pas 0.
## Exemples
La requête suivante renvoie la variance arrondie entre l’échantillon et la population de la colonne NUMTICKETS dans la table LISTING.
```
select avg(numtickets),
round(var_samp(numtickets)) varsamp,
round(var_pop(numtickets)) varpop
from listing;
avg | varsamp | varpop
-----+---------+--------
10 | 54 | 54
(1 row)
```
La requête suivante exécute les mêmes calculs mais traduit les résultats en valeur décimales.
```
select avg(numtickets),
cast(var_samp(numtickets) as dec(10,4)) varsamp,
cast(var_pop(numtickets) as dec(10,4)) varpop
from listing;
avg | varsamp | varpop
-----+---------+---------
10 | 53.6291 | 53.6288
(1 row)
```