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
Les fonctions d'agrégation de AWS Clean Rooms Spark SQL sont utilisées pour effectuer des calculs ou des opérations sur un groupe de lignes et renvoyer une valeur unique. Ils sont essentiels pour les tâches d'analyse et de synthèse des données.
AWS Clean Rooms Spark SQL prend en charge les fonctions d'agrégation suivantes :
**Topics**
+ [Fonction ANY\$1VALUE](ANY_VALUE.md)
+ [Fonction APPROX COUNT\$1DISTINCT](approx-count-distinct.md)
+ [Fonction APPROX PERCENTILE](approx-percentile.md)
+ [Fonction AVG](avg-function.md)
+ [Fonction BOOL\$1AND](BOOL_AND.md)
+ [Fonction BOOL\$1OR](BOOL_OR.md)
+ [Fonction CARDINALITY](CARDINALITY.md)
+ [Fonction COLLECT\$1LIST](COLLECT_LIST.md)
+ [Fonction COLLECT\$1SET](COLLECT_SET.md)
+ [COUNTet COUNT DISTINCT fonctions](count-function.md)
+ [Fonction COUNT](COUNT.md)
+ [Fonction MAX](MAX.md)
+ [Fonction MEDIAN](MEDIAN.md)
+ [Fonction MIN](MIN.md)
+ [Fonction PERCENTILE](percentile.md)
+ [Fonction SKEWNESS](SKEWNESS.md)
+ [Fonctions STDDEV\$1SAMP et STDDEV\$1POP](STDDEV_functions.md)
+ [SUMet SUM DISTINCT fonctions](sum-function.md)
+ [Fonctions VAR\$1SAMP et VAR\$1POP](VARIANCE_functions.md)
# 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 peut renvoyer la valeur NULL si l'expression en entrée n'entraîne pas de renvoi de ligne.
## Syntaxe
```
ANY_VALUE (expression[, isIgnoreNull] )
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère. L’*expression* est l’un des types de données suivants :
*isIgnoreNull*
Un booléen qui détermine si la fonction doit renvoyer uniquement des valeurs non nulles.
## 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
L'exemple suivant renvoie une instance de n'importe quel `dateid` endroit où se `eventname` trouve le`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` endroit où `eventname` 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 APPROX COUNT\$1DISTINCT
APPROX COUNT\$1DISTINCT fournit un moyen efficace d'estimer le nombre de valeurs uniques dans une colonne ou un ensemble de données.
## Syntaxe
```
approx_count_distinct(expr[, relativeSD])
```
## Arguments
*expr*
Expression ou colonne pour laquelle vous souhaitez estimer le nombre de valeurs uniques.
Il peut s'agir d'une seule colonne, d'une expression complexe ou d'une combinaison de colonnes.
*Membres de la famille D*
Paramètre facultatif qui spécifie l'écart type relatif souhaité de l'estimation.
Il s'agit d'une valeur comprise entre 0 et 1, représentant l'erreur relative maximale acceptable de l'estimation. Une valeur RelativeSD plus faible se traduira par une estimation plus précise mais plus lente.
Si ce paramètre n'est pas fourni, une valeur par défaut (généralement autour de 0,05 ou 5 %) est utilisée.
## Renvoie
Renvoie la cardinalité estimée par HyperLogLog \$1\$1. RelativeSD définit l'écart type relatif maximal autorisé.
## Exemple
La requête suivante estime le nombre de valeurs uniques dans la `col1` colonne, avec un écart type relatif de 1 % (0,01).
```
SELECT approx_count_distinct(col1, 0.01)
```
La requête suivante estime que la `col1` colonne contient 3 valeurs uniques (les valeurs 1, 2 et 3).
```
SELECT approx_count_distinct(col1) FROM VALUES (1), (1), (2), (2), (3) tab(col1)
```
# Fonction APPROX PERCENTILE
APPROX PERCENTILE est utilisé pour estimer la valeur percentile d'une expression ou d'une colonne donnée sans avoir à trier l'ensemble de données dans son intégralité. Cette fonction est utile dans les scénarios dans lesquels vous devez comprendre rapidement la distribution d'un ensemble de données volumineux ou suivre des métriques basées sur des percentiles, sans les frais de calcul liés à un calcul de percentile exact. Cependant, il est important de comprendre les compromis entre vitesse et précision, et de choisir la tolérance d'erreur appropriée en fonction des exigences spécifiques de votre cas d'utilisation.
## Syntaxe
```
APPROX_PERCENTILE(expr, percentile [, accuracy])
```
## Arguments
*expr*
Expression ou colonne pour laquelle vous souhaitez estimer la valeur du percentile.
Il peut s'agir d'une seule colonne, d'une expression complexe ou d'une combinaison de colonnes.
*percentile*
La valeur du percentile que vous souhaitez estimer, exprimée sous la forme d'une valeur comprise entre 0 et 1.
Par exemple, 0,5 correspondrait au 50e percentile (médiane).
*précision*
Paramètre facultatif qui spécifie la précision souhaitée de l'estimation du percentile. Il s'agit d'une valeur comprise entre 0 et 1, représentant l'erreur relative maximale acceptable de l'estimation. Une `accuracy` valeur inférieure se traduira par une estimation plus précise mais plus lente. Si ce paramètre n'est pas fourni, une valeur par défaut (généralement autour de 0,05 ou 5 %) est utilisée.
## Renvoie
Renvoie le percentile approximatif de la colonne d'intervalle numérique ou ANSI col qui est la plus petite valeur parmi les valeurs de col ordonnées (triées de la plus petite à la plus grande), de telle sorte qu'un pourcentage maximum de valeurs de col ne soit inférieur à la valeur ou égal à cette valeur.
La valeur du pourcentage doit être comprise entre 0,0 et 1,0. Le paramètre de précision (par défaut : 10000) est un littéral numérique positif qui contrôle la précision des approximations au détriment de la mémoire.
Une valeur de précision plus élevée donne une meilleure précision, `1.0/accuracy` c'est-à-dire l'erreur relative de l'approximation.
Lorsque le pourcentage est un tableau, chaque valeur du tableau de pourcentage doit être comprise entre 0,0 et 1,0. Dans ce cas, renvoie le tableau de percentiles approximatif de la colonne col pour le tableau de pourcentages donné.
## Exemples
La requête suivante estime le 95e percentile de la `response_time` colonne, avec une erreur relative maximale de 1 % (0,01).
```
SELECT APPROX_PERCENTILE(response_time, 0.95, 0.01) AS p95_response_time
FROM my_table;
```
La requête suivante estime les valeurs des 50e, 40e et 10e percentiles de la `col` colonne du tableau. `tab`
```
SELECT approx_percentile(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col)
```
La requête suivante estime le 50e percentile (médiane) des valeurs de la colonne col.
```
SELECT approx_percentile(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col)
```
# Fonction AVG
La AVG fonction renvoie la moyenne (moyenne arithmétique) des valeurs des expressions d'entrée. La AVG fonction fonctionne avec des valeurs numériques et ignore les valeurs NULL.
## Syntaxe
```
AVG (column)
```
## Arguments
*column*
Colonne cible sur laquelle la fonction opère. La colonne est de l'un des types de données suivants :
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ DOUBLE
+ FLOAT
## Types de données
Les types d'arguments pris en charge par la AVG fonction sont SMALLINT INTEGERBIGINT,DECIMAL, etDOUBLE.
Les types de retour pris en charge par la AVG fonction sont les suivants :
+ BIGINTpour tout argument de type entier
+ DOUBLEpour 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 pour le résultat d'une AVG fonction avec un DECIMAL argument est de 38. L’échelle du résultat est identique à celle de l’argument. Par exemple, AVG une DEC(5,2) colonne renvoie un type de DEC(38,2) données.
## Exemple
Trouvez la quantité moyenne vendue par transaction dans le SALES tableau.
```
select avg(qtysold) from sales;
```
# Fonction BOOL\$1AND
La fonction BOOL\$1AND opère sur une seule colonne ou expression booléenne ou entière. Elle applique une logique similaire aux fonctions BIT\$1AND et BIT\$1OR. Pour cette fonction, le type de retour est une valeur booléenne (`true` ou `false`).
Si toutes les valeurs d’un ensemble sont true, la fonction BOOL\$1AND renvoie `true` (`t`). Si une valeur est false, la fonction renvoie `false` (`f`).
## Syntaxe
```
BOOL_AND ( [DISTINCT | ALL] expression )
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère. Cette expression doit comporter un type de données BOOLEAN ou nombre entier. Le type de retour de la fonction est BOOLEAN.
DISTINCT \$1 ALL
Avec l’argument DISTINCT, la fonction supprime toutes les valeurs en double de l’expression spécifiée avant de calculer le résultat. Avec l’argument ALL, la fonction conserve toutes les valeurs en double. La valeur par défaut est ALL.
## Exemples
Vous pouvez utiliser les fonctions booléennes par rapport à des expressions booléennes ou à des expressions de type nombre entier.
Par exemple, la requête suivante renvoie les résultats de la table USERS standard de la base de données TICKIT, qui comporte plusieurs colonnes booléennes.
La fonction BOOL\$1AND renvoie `false` pour les cinq lignes. Tous les utilisateurs de chacun de ces états n’aiment pas le sport.
```
select state, bool_and(likesports) from users
group by state order by state limit 5;
state | bool_and
------+---------
AB | f
AK | f
AL | f
AZ | f
BC | f
(5 rows)
```
# Fonction BOOL\$1OR
La fonction BOOL\$1OR opère sur une seule colonne ou expression booléenne ou entière. Elle applique une logique similaire aux fonctions BIT\$1AND et BIT\$1OR. Pour cette fonction, le type de retour est une valeur booléenne (`true`, `false` ou `NULL`).
Si une valeur d’un ensemble est `true`, la fonction BOOL\$1OR renvoie `true` (`t`). Si une valeur d’un ensemble est `false`, la fonction renvoie `false` (`f`). La valeur NULL peut être renvoyée si la valeur est inconnue.
## Syntaxe
```
BOOL_OR ( [DISTINCT | ALL] expression )
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère. Cette expression doit comporter un type de données BOOLEAN ou nombre entier. Le type de retour de la fonction est BOOLEAN.
DISTINCT \$1 ALL
Avec l’argument DISTINCT, la fonction supprime toutes les valeurs en double de l’expression spécifiée avant de calculer le résultat. Avec l’argument ALL, la fonction conserve toutes les valeurs en double. La valeur par défaut est ALL.
## Exemples
Vous pouvez utiliser les fonctions booléennes avec des expressions booléennes ou des expressions de type nombre entier. Par exemple, la requête suivante renvoie les résultats de la table USERS standard de la base de données TICKIT, qui comporte plusieurs colonnes booléennes.
La fonction BOOL\$1OR renvoie `true` pour les cinq lignes. Au moins un utilisateur de chacun de ces états aime le sport.
```
select state, bool_or(likesports) from users
group by state order by state limit 5;
state | bool_or
------+--------
AB | t
AK | t
AL | t
AZ | t
BC | t
(5 rows)
```
L’exemple suivant renvoie la valeur NULL.
```
SELECT BOOL_OR(NULL = '123')
bool_or
------
NULL
```
# Fonction CARDINALITY
La fonction CARDINALITY renvoie la taille d'une expression ARRAY ou MAP (*expr*).
Cette fonction est utile pour déterminer la taille ou la longueur d'un tableau.
## Syntaxe
```
cardinality(expr)
```
## Arguments
*expr*
Expression ARRAY ou MAP.
## Renvoie
Renvoie la taille d'un tableau ou d'une carte (INTEGER).
La fonction renvoie `NULL` une entrée nulle si elle `sizeOfNull` est définie sur `false` ou `enabled` est définie sur`true`.
Dans le cas contraire, la fonction renvoie `-1` une entrée nulle. Avec les paramètres par défaut, la fonction renvoie `-1` une entrée nulle.
## Exemple
La requête suivante calcule la cardinalité, ou le nombre d'éléments, dans le tableau donné. Le tableau (`'b', 'd', 'c', 'a'`) comporte 4 éléments, donc le résultat de cette requête serait`4`.
```
SELECT cardinality(array('b', 'd', 'c', 'a'));
4
```
# Fonction COLLECT\$1LIST
La fonction COLLECT\$1LIST collecte et renvoie une liste d'éléments non uniques.
Ce type de fonction est utile lorsque vous souhaitez collecter plusieurs valeurs d'un ensemble de lignes dans une seule structure de données de type tableau ou liste.
**Note**
La fonction n'est pas déterministe car l'ordre des résultats collectés dépend de l'ordre des lignes, qui peut être non déterministe après l'exécution d'une opération de brassage.
## Syntaxe
```
collect_list(expr)
```
## Arguments
*expr*
Expression de n'importe quel type.
## Renvoie
Renvoie un ARRAY du type d'argument. L'ordre des éléments du tableau n'est pas déterministe.
Les valeurs NULL sont exclues.
Si DISTINCT est spécifié, la fonction collecte uniquement des valeurs uniques et est synonyme de fonction d'`collect_set `agrégation.
## Exemple
La requête suivante rassemble toutes les valeurs de la colonne col dans une liste. La `VALUES` clause est utilisée pour créer un tableau en ligne de trois lignes, où chaque ligne possède une seule colonne col avec les valeurs 1, 2 et 1 respectivement. La `collect_list() ` fonction est ensuite utilisée pour agréger toutes les valeurs de la colonne col dans un seul tableau. La sortie de cette instruction SQL serait le tableau`[1,2,1]`, qui contient toutes les valeurs de la colonne col dans l'ordre dans lequel elles apparaissent dans les données d'entrée.
```
SELECT collect_list(col) FROM VALUES (1), (2), (1) AS tab(col);
[1,2,1]
```
# Fonction COLLECT\$1SET
La fonction COLLECT\$1SET collecte et renvoie un ensemble d'éléments uniques.
Cette fonction est utile lorsque vous souhaitez collecter toutes les valeurs distinctes d'un ensemble de lignes dans une structure de données unique, sans inclure de doublons.
**Note**
La fonction n'est pas déterministe car l'ordre des résultats collectés dépend de l'ordre des lignes, qui peut être non déterministe après l'exécution d'une opération de brassage.
## Syntaxe
```
collect_set(expr)
```
## Arguments
*expr*
Expression de n'importe quel type sauf MAP.
## Renvoie
Renvoie un ARRAY du type d'argument. L'ordre des éléments du tableau n'est pas déterministe.
Les valeurs NULL sont exclues.
## Exemple
La requête suivante rassemble toutes les valeurs uniques de la colonne col dans un ensemble. La `VALUES` clause est utilisée pour créer un tableau en ligne de trois lignes, où chaque ligne possède une seule colonne col avec les valeurs 1, 2 et 1 respectivement. La `collect_set()` fonction est ensuite utilisée pour agréger toutes les valeurs uniques de la colonne col en un seul ensemble. Le résultat de cette instruction SQL serait le set`[1,2]`, qui contient les valeurs uniques de la colonne col. La valeur dupliquée de 1 n'est incluse qu'une seule fois dans le résultat.
```
SELECT collect_set(col) FROM VALUES (1), (2), (1) AS tab(col);
[1,2]
```
# COUNTet COUNT DISTINCT fonctions
La COUNT fonction compte les lignes définies par l'expression. La COUNT DISTINCT fonction calcule le nombre de valeurs non nulles distinctes dans une colonne ou une expression. Il élimine toutes les valeurs dupliquées de l'expression spécifiée avant de procéder au décompte.
## Syntaxe
```
COUNT (DISTINCT column)
```
## Arguments
*column*
Colonne cible sur laquelle la fonction opère.
## Types de données
La COUNT fonction et la COUNT DISTINCT fonction prennent en charge tous les types de données d'arguments.
La COUNT DISTINCT fonction revientBIGINT.
## Exemples
Comptez tous les utilisateurs de l'État de Floride.
```
select count (identifier) from users where state='FL';
```
Comptez tous les lieux uniques IDs à partir de la EVENT table.
```
select count (distinct venueid) as venues from event;
```
# 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.
## Syntaxe
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] 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.
## 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
...
```
# 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 un type de données numérique quelconque.
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*.
## 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
## Syntaxe
```
MEDIAN ( median_expression )
```
## Arguments
*median\$1expression*
Colonne cible ou expression sur laquelle la fonction opère.
# 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 un type de données numérique quelconque.
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*.
## 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
La fonction PERCENTILE est utilisée pour calculer la valeur percentile exacte en triant d'abord les valeurs dans la `col` colonne, puis en recherchant la valeur spécifiée. `percentage`
La fonction PERCENTILE est utile lorsque vous devez calculer la valeur exacte du percentile et que le coût de calcul est acceptable pour votre cas d'utilisation. Elle fournit des résultats plus précis que la fonction APPROX\$1PERCENTILE, mais elle peut être plus lente, en particulier pour les grands ensembles de données.
En revanche, la fonction APPROX\$1PERCENTILE est une alternative plus efficace qui peut fournir une estimation de la valeur du percentile avec une tolérance d'erreur spécifiée, ce qui la rend plus adaptée aux scénarios où la vitesse est une priorité supérieure à la précision absolue.
## Syntaxe
```
percentile(col, percentage [, frequency])
```
## Arguments
*col*
Expression ou colonne pour laquelle vous souhaitez calculer la valeur du percentile.
*pourcentage*
La valeur du percentile que vous souhaitez calculer, exprimée sous la forme d'une valeur comprise entre 0 et 1.
Par exemple, 0,5 correspondrait au 50e percentile (médiane).
*fréquence*
Paramètre facultatif qui spécifie la fréquence ou le poids de chaque valeur de la `col` colonne. S'il est fourni, la fonction calculera le percentile en fonction de la fréquence de chaque valeur.
## Renvoie
Renvoie la valeur percentile exacte de la colonne d'intervalle numérique ou ANSI col au pourcentage donné.
La valeur du pourcentage doit être comprise entre 0,0 et 1,0.
La valeur de la fréquence doit être une intégrale positive
## Exemple
La requête suivante trouve la valeur supérieure ou égale à 30 % des valeurs de la `col` colonne. Les valeurs étant 0 et 10, le 30e percentile est de 3,0, car il s'agit de la valeur supérieure ou égale à 30 % des données.
```
SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);
3.0
```
# Fonction SKEWNESS
La fonction SKEWNESS renvoie la valeur d'asymétrie calculée à partir des valeurs d'un groupe.
L'asymétrie est une mesure statistique qui décrit l'asymétrie ou le manque de symétrie d'un ensemble de données. Il fournit des informations sur la forme de la distribution des données.
Cette fonction peut être utile pour comprendre les propriétés statistiques d'un ensemble de données et éclairer les analyses ultérieures ou la prise de décision.
## Syntaxe
```
skewness(expr)
```
## Arguments
*expr*
Expression dont l'évaluation est une valeur numérique.
## Renvoie
Renvoie DOUBLE.
Si DISTINCT est spécifié, la fonction ne fonctionne que sur un ensemble unique de valeurs *expr.*
## Exemples
La requête suivante calcule l'asymétrie des valeurs de la colonne. `col` Dans cet exemple, la `VALUES` clause est utilisée pour créer un tableau en ligne de quatre lignes, où chaque ligne possède une seule colonne `col` avec les valeurs -10, -20, 100 et 1000. La `skewness()` fonction est ensuite utilisée pour calculer l'asymétrie des valeurs de la colonne. `col` Le résultat, 1,1135657469022011, représente le degré et la direction de l'asymétrie des données. Une valeur d'asymétrie positive indique que les données sont inclinées vers la droite, la majeure partie des valeurs étant concentrée sur le côté gauche de la distribution. Une valeur d'asymétrie négative indique que les données sont inclinées vers la gauche, la majeure partie des valeurs étant concentrée sur le côté droit de la distribution.
```
SELECT skewness(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
1.1135657469022011
```
La requête suivante calcule l'asymétrie des valeurs de la colonne col. Comme dans l'exemple précédent, la `VALUES` clause est utilisée pour créer un tableau en ligne de quatre lignes, où chaque ligne possède une seule colonne `col` avec les valeurs -1000, -100, 10 et 20. La `skewness()` fonction est ensuite utilisée pour calculer l'asymétrie des valeurs de la colonne. `col` Le résultat, -1,1135657469022011, représente le degré et la direction de l'asymétrie des données. Dans ce cas, la valeur d'asymétrie négative indique que les données sont inclinées vers la gauche, la majeure partie des valeurs étant concentrée sur le côté droit de la distribution.
```
SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);
-1.1135657469022011
```
# 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 avoir un type de données numérique. 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)
```
# SUMet SUM DISTINCT fonctions
La SUM fonction renvoie la somme des valeurs de colonne ou d'expression en entrée. La SUM fonction fonctionne avec des valeurs numériques et ignore NULL les valeurs.
La SUM DISTINCT fonction élimine toutes les valeurs dupliquées de l'expression spécifiée avant de calculer la somme.
## Syntaxe
```
SUM (DISTINCT column )
```
## Arguments
*column*
Colonne cible sur laquelle la fonction opère. La colonne contient tous les types de données numériques.
## Exemples
Trouvez la somme de toutes les commissions payées dans le SALES tableau.
```
select sum(commission) from sales
```
Trouvez la somme de toutes les commissions distinctes payées dans le SALES tableau.
```
select sum (distinct (commission)) from sales
```
# 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)
```