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.
# AWS Clean Rooms Fonctions Spark SQL
AWS Clean Rooms Spark SQL prend en charge les fonctions SQL suivantes :
**Topics**
+ [Fonctions d’agrégation](sql-functions-agg-spark.md)
+ [Fonctions de tableau](Array_Functions.md)
+ [Expressions conditionnelles](sql-functions-conditional-expressions-spark.md)
+ [Fonctions de constructeur](sql-functions-constructor.md)
+ [Fonctions de formatage des types de données](Data_type_formatting.md)
+ [Fonctions de date et d’heure](date-time-functions-spark.md)
+ [Fonctions de chiffrement et de déchiffrement](encryption-decryption-functions.md)
+ [Fonctions de hachage](s_hash-functions.md)
+ [Fonctions Hyperloglog](hyperloglog-functions.md)
+ [Fonctions JSON](json-functions-spark.md)
+ [Fonctions mathématiques](Math_functions-spark.md)
+ [Fonctions scalaires](scalar_functions.md)
+ [Fonctions de chaîne](String_functions_spark.md)
+ [Fonctions liées à la confidentialité](privacy-related-functions.md)
+ [Fonctions de fenêtrage](Window_functions.md)
# 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)
```
# Fonctions de tableau
Cette section décrit les fonctions de tableau pour SQL prises en charge dans AWS Clean Rooms.
**Topics**
+ [Fonction ARRAY](array.md)
+ [Fonction ARRAY\$1CONTAINS](array_contains.md)
+ [Fonction ARRAY\$1DISTINCT](array_distinct.md)
+ [Fonction ARRAY\$1EXCEPT](array_except.md)
+ [Fonction ARRAY\$1INTERSECT](array_intersect.md)
+ [Fonction ARRAY\$1JOIN](array_join.md)
+ [Fonction ARRAY\$1REMOVE](array_remove.md)
+ [Fonction ARRAY\$1UNION](array_union.md)
+ [Fonction EXPLODE](explode.md)
+ [Fonction FLATTEN](flatten.md)
# Fonction ARRAY
Crée un tableau avec les éléments donnés.
## Syntaxe
```
ARRAY( [ expr1 ] [ , expr2 [ , ... ] ] )
```
## Argument
*expr1, expr2*
Expressions de tous types de données, à l'exception des types de date et d'heure. Les arguments ne doivent pas nécessairement être du même type de données.
## Type de retour
La fonction array renvoie un ARRAY contenant les éléments de l'expression.
## exemple
L'exemple suivant montre un tableau de valeurs numériques et un tableau de différents types de données.
```
--an array of numeric values
select array(1,50,null,100);
array
------------------
[1,50,null,100]
(1 row)
--an array of different data types
select array(1,'abc',true,3.14);
array
-----------------------
[1,"abc",true,3.14]
(1 row)
```
# Fonction ARRAY\$1CONTAINS
La fonction ARRAY\$1CONTAINS peut être utilisée pour effectuer des vérifications d'appartenance de base sur les structures de données des tableaux. La fonction ARRAY\$1CONTAINS est utile lorsque vous devez vérifier si une valeur spécifique est présente dans un tableau.
## Syntaxe
```
array_contains(array, value)
```
## Arguments
*réseau*
Un ARRAY à rechercher.
*valeur*
Expression dont le type partage le type le moins courant avec les éléments du tableau.
## Type de retour
La fonction ARRAY\$1CONTAINS renvoie une valeur BOOLEAN.
Si la valeur est NULL, le résultat est NULL.
Si un élément du tableau est NULL, le résultat est NULL si la valeur ne correspond à aucun autre élément.
## Exemples
L'exemple suivant vérifie si le tableau `[1, 2, 3]` contient la valeur`4`. Comme le `[1, 2, 3` [array] ne contient pas la valeur`4`, la fonction array\$1contains revient. `false`
```
SELECT array_contains(array(1, 2, 3), 4)
false
```
L'exemple suivant vérifie si le tableau `[1, 2, 3]` contient la valeur`2`. Comme le tableau `[1, 2, 3]` contient la valeur`2`, la fonction array\$1contains est renvoyée. `true`
```
SELECT array_contains(array(1, 2, 3), 2);
true
```
# Fonction ARRAY\$1DISTINCT
La fonction ARRAY\$1DISTINCT peut être utilisée pour supprimer les valeurs dupliquées d'un tableau. La fonction ARRAY\$1DISTINCT est utile lorsque vous devez supprimer les doublons d'un tableau et utiliser uniquement les éléments uniques. Cela peut être utile dans les scénarios où vous souhaitez effectuer des opérations ou des analyses sur un ensemble de données sans l'interférence de valeurs répétées.
## Syntaxe
```
array_distinct(array)
```
## Arguments
*réseau*
Expression ARRAY.
## Type de retour
La fonction ARRAY\$1DISTINCT renvoie un ARRAY contenant uniquement les éléments uniques du tableau d'entrée.
## Exemples
Dans cet exemple, le tableau d'entrée `[1, 2, 3, null, 3]` contient une valeur dupliquée de`3`. La `array_distinct` fonction supprime cette valeur dupliquée `3` et renvoie un nouveau tableau contenant les éléments uniques :`[1, 2, 3, null]`.
```
SELECT array_distinct(array(1, 2, 3, null, 3));
[1,2,3,null]
```
Dans cet exemple, le tableau d'entrée `[1, 2, 2, 3, 3, 3]` contient des valeurs dupliquées de `2` et`3`. La `array_distinct` fonction supprime ces doublons et renvoie un nouveau tableau avec les éléments uniques :. `[1, 2, 3]`
```
SELECT array_distinct(array(1, 2, 2, 3, 3, 3))
[1,2,3]
```
# Fonction ARRAY\$1EXCEPT
La fonction ARRAY\$1EXCEPT prend deux tableaux comme arguments et renvoie un nouveau tableau contenant uniquement les éléments présents dans le premier tableau, mais pas dans le second tableau.
Le ARRAY\$1EXCEPT est utile lorsque vous devez trouver les éléments uniques d'un tableau par rapport à un autre. Cela peut être utile dans les scénarios où vous devez effectuer des opérations similaires à des ensembles sur des tableaux, telles que la recherche de la différence entre deux ensembles de données.
## Syntaxe
```
array_except(array1, array2)
```
## Arguments
*matrice1*
Un ARRAY de n'importe quel type avec des éléments comparables.
*tableau 2*
Un TABLEAU d'éléments partageant le type le moins commun avec les éléments de *array1*.
## Type de retour
La fonction ARRAY\$1EXCEPT renvoie un ARRAY de type correspondant à *array1* sans doublons.
## Exemples
Dans cet exemple, le premier tableau `[1, 2, 3]` contient les éléments 1, 2 et 3. Le second tableau `[2, 3, 4]` contient les éléments 2, 3 et 4. La `array_except` fonction supprime les éléments 2 et 3 du premier tableau, puisqu'ils sont également présents dans le second tableau. Le résultat obtenu est le tableau`[1]`.
```
SELECT array_except(array(1, 2, 3), array(2, 3, 4))
[1]
```
Dans cet exemple, le premier tableau `[1, 2, 3]` contient les éléments 1, 2 et 3. Le second tableau `[1, 3, 5]` contient les éléments 1, 3 et 5. La `array_except` fonction supprime les éléments 1 et 3 du premier tableau, puisqu'ils sont également présents dans le second tableau. Le résultat obtenu est le tableau`[2]`.
```
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
[2]
```
# Fonction ARRAY\$1INTERSECT
La fonction ARRAY\$1INTERSECT prend deux tableaux comme arguments et renvoie un nouveau tableau contenant les éléments présents dans les deux tableaux d'entrée. Cette fonction est utile lorsque vous devez trouver les éléments communs entre deux tableaux. Cela peut être utile dans les scénarios où vous devez effectuer des opérations similaires à des ensembles sur des tableaux, telles que la recherche de l'intersection entre deux ensembles de données.
## Syntaxe
```
array_intersect(array1, array2)
```
## Arguments
*matrice1*
Un ARRAY de n'importe quel type avec des éléments comparables.
*tableau 2*
Un TABLEAU d'éléments partageant le type le moins commun avec les éléments de array1.
## Type de retour
La fonction ARRAY\$1INTERSECT renvoie un ARRAY de type correspondant à array1 sans doublons et sans éléments contenus à la fois dans array1 et array2.
## Exemples
Dans cet exemple, le premier tableau `[1, 2, 3]` contient les éléments 1, 2 et 3. Le second tableau `[1, 3, 5]` contient les éléments 1, 3 et 5. La fonction ARRAY\$1INTERSECT identifie les éléments communs entre les deux tableaux, à savoir 1 et 3. Le tableau de sortie résultant est`[1, 3]`.
```
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
[1,3]
```
# Fonction ARRAY\$1JOIN
La fonction ARRAY\$1JOIN prend deux arguments : le premier argument est le tableau d'entrée qui sera joint. Le deuxième argument est la chaîne de séparation qui sera utilisée pour concaténer les éléments du tableau. Cette fonction est utile lorsque vous devez convertir un tableau de chaînes (ou tout autre type de données) en une seule chaîne concaténée. Cela peut être utile dans les scénarios où vous souhaitez présenter un tableau de valeurs sous la forme d'une seule chaîne formatée, par exemple à des fins d'affichage ou pour un traitement ultérieur.
## Syntaxe
```
array_join(array, delimiter[, nullReplacement])
```
## Arguments
*réseau*
N'importe quel type ARRAY, mais ses éléments sont interprétés comme des chaînes.
*delimiter*
Une CHAÎNE utilisée pour séparer les éléments du tableau concaténé.
*Remplacement nul*
Chaîne utilisée pour exprimer une valeur NULL dans le résultat.
## Type de retour
La fonction ARRAY\$1JOIN renvoie une chaîne dans laquelle les éléments du tableau sont séparés par un délimiteur et les éléments nuls sont remplacés par des éléments nuls. `nullReplacement` Si `nullReplacement` ce paramètre est omis, `null` les éléments sont filtrés. Si un argument l'est`NULL`, le résultat est`NULL`.
## Exemples
Dans cet exemple, la fonction ARRAY\$1JOIN prend le tableau `['hello', 'world']` et joint les éléments à l'aide du séparateur `' '` (un espace). Le résultat obtenu est la chaîne de caractères`'hello world'`.
```
SELECT array_join(array('hello', 'world'), ' ');
hello world
```
Dans cet exemple, la fonction ARRAY\$1JOIN prend le tableau `['hello', null, 'world']` et joint les éléments à l'aide du séparateur `' '` (un espace). La `null` valeur est remplacée par la chaîne de remplacement fournie `','` (une virgule). Le résultat obtenu est la chaîne de caractères`'hello , world'`.
```
SELECT array_join(array('hello', null ,'world'), ' ', ',');
hello , world
```
# Fonction ARRAY\$1REMOVE
La fonction ARRAY\$1REMOVE accepte deux arguments : le premier argument est le tableau d'entrée dont les éléments seront supprimés. Le deuxième argument est la valeur qui sera supprimée du tableau. Cette fonction est utile lorsque vous devez supprimer des éléments spécifiques d'un tableau. Cela peut être utile dans les scénarios où vous devez effectuer un nettoyage ou un prétraitement des données sur un tableau de valeurs.
## Syntaxe
```
array_remove(array, element)
```
## Arguments
*réseau*
Un ARRAY.
*élément*
Expression d'un type partageant le type le moins commun avec les éléments du tableau.
## Type de retour
La fonction ARRAY\$1REMOVE renvoie le type de résultat correspondant au type du tableau. Si l'élément à supprimer l'est`NULL`, le résultat est`NULL`.
## Exemples
Dans cet exemple, la fonction ARRAY\$1REMOVE prend le tableau `[1, 2, 3, null, 3]` et supprime toutes les occurrences de la valeur 3. Le résultat obtenu est le tableau`[1, 2, null]`.
```
SELECT array_remove(array(1, 2, 3, null, 3), 3);
[1,2,null]
```
# Fonction ARRAY\$1UNION
La fonction ARRAY\$1UNION prend deux tableaux comme arguments et renvoie un nouveau tableau contenant les éléments uniques des deux tableaux d'entrée. Cette fonction est utile lorsque vous devez combiner deux tableaux et éliminer les éléments dupliqués. Cela peut être utile dans les scénarios où vous devez effectuer des opérations similaires à des ensembles sur des tableaux, telles que la recherche de l'union entre deux ensembles de données.
## Syntaxe
```
array_union(array1, array2)
```
## Arguments
*matrice1*
Un ARRAY.
*tableau 2*
Un ARRAY du même type que *array1*.
## Type de retour
La fonction ARRAY\$1UNION renvoie un ARRAY du même type qu'un tableau.
## exemple
Dans cet exemple, le premier tableau `[1, 2, 3]` contient les éléments 1, 2 et 3. Le second tableau `[1, 3, 5]` contient les éléments 1, 3 et 5. La fonction ARRAY\$1UNION combine les éléments uniques des deux tableaux pour obtenir le tableau de sortie. `[1, 2, 3, 5]` T
```
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
[1,2,3,5]
```
# Fonction EXPLODE
La fonction EXPLODE est utilisée pour transformer une seule ligne contenant un tableau ou une colonne de carte en plusieurs lignes, chaque ligne correspondant à un seul élément du tableau ou de la carte.
## Syntaxe
```
explode(expr)
```
## Arguments
*expr*
Expression matricielle ou expression cartographique.
## Type de retour
La fonction EXPLODE renvoie un ensemble de lignes, chaque ligne représentant un élément unique du tableau ou de la carte en entrée.
Le type de données des lignes de sortie dépend du type de données des éléments du tableau ou de la carte en entrée.
## Exemples
L'exemple suivant prend le tableau à une seule ligne [10, 20] et le transforme en deux lignes distinctes, chacune contenant l'un des éléments du tableau (10 et 20).
```
SELECT explode(array(10, 20));
```
Dans le premier exemple, le tableau d'entrée a été directement transmis en tant qu'argument à`explode()`. Dans cet exemple, le tableau d'entrée est spécifié à l'aide de la `=>` syntaxe, où le nom de colonne (`collection`) est explicitement fourni.
```
SELECT explode(array(10, 20));
```
Les deux approches sont valides et permettent d'obtenir le même résultat, mais la seconde syntaxe peut être plus utile lorsque vous devez faire exploser une colonne d'un ensemble de données plus important, plutôt qu'un simple tableau littéral.
# Fonction FLATTEN
La fonction FLATTEN est utilisée pour « aplatir » une structure de tableau imbriqué en un seul tableau plat.
## Syntaxe
```
flatten(arrayOfArrays)
```
## Arguments
*arrayOfArrays*
Un tableau de tableaux.
## Type de retour
La fonction FLATTEN renvoie un tableau.
## exemple
Dans cet exemple, l'entrée est un tableau imbriqué avec deux tableaux internes, et la sortie est un seul tableau plat contenant tous les éléments des tableaux internes. La fonction FLATTEN prend le tableau imbriqué `[[1, 2], [3, 4]]` et combine tous les éléments en un seul tableau. `[1, 2, 3, 4]`
```
SELECT flatten(array(array(1, 2), array(3, 4)));
[1,2,3,4]
```
# Expressions conditionnelles
En SQL, les expressions conditionnelles sont utilisées pour prendre des décisions en fonction de certaines conditions. Ils vous permettent de contrôler le flux de vos instructions SQL et de renvoyer différentes valeurs ou d'effectuer différentes actions en fonction de l'évaluation d'une ou de plusieurs conditions.
AWS Clean Rooms prend en charge les expressions conditionnelles suivantes :
**Topics**
+ [Expression conditionnelle CASE](CASE_function.md)
+ [COALESCEexpression](coalesce-function.md)
+ [La plus grande et la moins grande expression](GREATEST_LEAST.md)
+ [Expression IF](IF.md)
+ [Expression IS\$1NULL](IS_NULL.md)
+ [Expression IS\$1NOT\$1NULL](IS_NOT_NULL.md)
+ [Fonctions NVL et COALESCE](NVL_function.md)
+ [NVL2 fonction](NVL2.md)
+ [Fonction NULLIF](NULLIF_function.md)
# Expression conditionnelle CASE
L'expression CASE est une expression conditionnelle, similaire aux if/then/else instructions trouvées dans d'autres langages. L’expression CASE est utilisée pour spécifier un résultat lorsqu’il y a plusieurs conditions. Utilisez CASE là où l’utilisation d’une expression SQL est valide, par exemple dans une commande SELECT.
Il existe deux types d’expressions CASE : simple et recherchée.
+ Dans les expressions CASE simples, une expression est comparée à une valeur. Lorsqu’une correspondance est trouvée, l’action spécifiée dans la clause THEN est appliquée. Si aucune correspondance n’est trouvée, l’action de la clause ELSE est appliquée.
+ Dans les expressions CASE recherchées, chaque expression CASE est évaluée en fonction d’une expression booléenne, et l’instruction CASE renvoie la première expression CASE correspondante. Si aucune correspondance n’est trouvée parmi les clauses WHEN, l’action contenue dans la clause ELSE est renvoyée.
## Syntaxe
Instruction CASE simple utilisée pour mettre en correspondance des conditions :
```
CASE expression
WHEN value THEN result
[WHEN...]
[ELSE result]
END
```
Instructions CASE recherchées utilisées pour évaluer chaque condition :
```
CASE
WHEN condition THEN result
[WHEN ...]
[ELSE result]
END
```
## Arguments
*expression*
Nom de la colonne ou n’importe quelle expression valide.
*valeur*
Valeur à laquelle l’expression est comparée, par exemple une constante numérique ou une chaîne de caractères.
*result*
Valeur ou expression cible qui est renvoyée lorsqu’une expression ou une condition booléenne est évaluée. Les types de données de toutes les expressions de résultat doivent pouvoir être convertis en un seul type de sortie.
*condition*
Expression booléenne qui prend la valeur true ou false. Si la *condition* a la valeur true, la valeur de l’expression CASE est le résultat qui suit la condition, et le reste de l’expression CASE n’est pas traité. Si la *condition* a la valeur false, les clauses WHEN suivantes sont évaluées. Si aucune condition WHEN n’a la valeur true en résultat, la valeur de l’expression CASE est le résultat de la clause ELSE. Si la clause ELSE est omise et qu’aucune condition n’a la valeur true, le résultat est null.
## Exemples
Utilisez une expression CASE simple pour remplacer `New York City` par `Big Apple` dans une requête sur la table de VENUE. Remplacer tous les autres noms de villes par `other`.
```
select venuecity,
case venuecity
when 'New York City'
then 'Big Apple' else 'other'
end
from venue
order by venueid desc;
venuecity | case
-----------------+-----------
Los Angeles | other
New York City | Big Apple
San Francisco | other
Baltimore | other
...
```
Utiliser une expression CASE recherchée pour affecter des numéros de groupes basés sur la valeur PRICEPAID pour les vente de billets individuelles :
```
select pricepaid,
case when pricepaid <10000 then 'group 1'
when pricepaid >10000 then 'group 2'
else 'group 3'
end
from sales
order by 1 desc;
pricepaid | case
----------+---------
12624 | group 2
10000 | group 3
10000 | group 3
9996 | group 1
9988 | group 1
...
```
# COALESCEexpression
Une COALESCE expression renvoie la valeur de la première expression de la liste qui n'est pas nulle. Si toutes les expressions régulières sont null, le résultat est null. Lorsqu'une valeur non null est trouvée, les expressions restantes de la liste ne sont pas évaluées.
Ce type d'expression s'avère utile lorsque vous souhaitez renvoyer une valeur de sauvegarde pour quelque chose lorsque la valeur préférée est manquante ou null. Par exemple, une requête peut renvoyer un des trois numéros de téléphone (portable, maison ou professionnel, dans l'ordre), selon ce qui est trouvé en premier dans le tableau (non null).
## Syntaxe
```
COALESCE (expression, expression, ... )
```
## Exemples
Appliquez COALESCE l'expression à deux colonnes.
```
select coalesce(start_date, end_date)
from datetable
order by 1;
```
Le nom de colonne par défaut pour une expression NVL estCOALESCE. La requête suivante renvoie les mêmes résultats.
```
select coalesce(start_date, end_date) from datetable order by 1;
```
# La plus grande et la moins grande expression
Renvoie la valeur la plus grande ou la plus petite d’une liste d’un nombre quelconque d’expressions.
## Syntaxe
```
GREATEST (value [, ...])
LEAST (value [, ...])
```
## Paramètres
*expression\$1list*
Liste d’expressions séparées par des virgules, telles que des noms de colonnes. Les expressions doivent toutes être converties dans un type de données commun. Les valeurs NULL de la liste sont ignorées. Si toutes les expressions sont évaluées à NULL, le résultat est NULL.
## Renvoie
Renvoie la plus grande (pour GREATEST) ou la plus petite (pour LEAST) valeur de la liste d’expressions fournie.
## exemple
L’exemple suivant renvoie la valeur la plus élevée dans l’ordre alphabétique pour `firstname` ou `lastname`.
```
select firstname, lastname, greatest(firstname,lastname) from users
where userid < 10
order by 3;
firstname | lastname | greatest
-----------+-----------+-----------
Alejandro | Rosalez | Ratliff
Carlos | Salazar | Carlos
Jane | Doe | Doe
John | Doe | Doe
John | Stiles | John
Shirley | Rodriguez | Rodriguez
Terry | Whitlock | Terry
Richard | Roe | Richard
Xiulan | Wang | Wang
(9 rows)
```
# Expression IF
La fonction conditionnelle IF renvoie l'une des deux valeurs en fonction d'une condition.
Cette fonction est une instruction de flux de contrôle courante utilisée dans SQL pour prendre des décisions et renvoyer différentes valeurs en fonction de l'évaluation d'une condition. C'est utile pour implémenter une logique if-else simple dans une requête.
## Syntaxe
```
if(expr1, expr2, expr3)
```
## Arguments
*expr1*
Condition ou expression évaluée. Si c'est le cas`true`, la fonction renverra la valeur de *expr2*. *Si *expr1* l'est`false`, la fonction renverra la valeur de expr3.*
*expr2*
Expression évaluée et renvoyée si *expr1* l'est. `true`
*expr3*
Expression évaluée et renvoyée si *expr1* l'est. `false`
## Renvoie
Si la `expr1` valeur est égale à`true`, renvoie `expr2` ; dans le cas contraire, renvoie`expr3`.
## exemple
L'exemple suivant utilise la `if()` fonction pour renvoyer l'une des deux valeurs en fonction d'une condition. La condition évaluée est `1 < 2``true`, c'est-à-dire que la première valeur `'a'` est renvoyée.
```
SELECT if(1 < 2, 'a', 'b');
a]
```
# Expression IS\$1NULL
L'expression IS\$1NULL conditionnelle est utilisée pour vérifier si une valeur est nulle.
Cette expression est synonyme deIS NULL.
## Syntaxe
```
is_null(expr)
```
## Arguments
*expr*
Expression de n'importe quel type.
## Renvoie
L'expression IS\$1NULL conditionnelle renvoie une valeur booléenne. Si la valeur `expr1` est NULL`true`, renvoie, sinon renvoie`false`.
## Exemples
L'exemple suivant vérifie si la valeur `1` est nulle et renvoie le résultat booléen `true` car 1 est une valeur valide et non nulle.
```
SELECT is not null(1);
true
```
L'exemple suivant sélectionne la `id` colonne dans le `squirrels` tableau, mais uniquement pour les lignes où se trouve la colonne d'âge`null`.
```
SELECT id FROM squirrels WHERE is_null(age)
```
# Expression IS\$1NOT\$1NULL
L'expression IS\$1NOT\$1NULL conditionnelle est utilisée pour vérifier si une valeur n'est pas nulle.
Cette expression est synonyme deIS NOT NULL.
## Syntaxe
```
is_not_null(expr)
```
## Arguments
*expr*
Expression de n'importe quel type.
## Renvoie
L'expression IS\$1NOT\$1NULL conditionnelle renvoie une valeur booléenne. Si `expr1` ce n'est pas NULL, renvoie`true`, sinon renvoie`false`.
## Exemples
L'exemple suivant vérifie si la valeur n'`1`est pas nulle et renvoie le résultat booléen `true` car 1 est une valeur valide et non nulle.
```
SELECT is not null(1);
true
```
L'exemple suivant sélectionne la `id` colonne dans le `squirrels` tableau, mais uniquement pour les lignes où la colonne d'âge ne figure pas`null`.
```
SELECT id FROM squirrels WHERE is_not_null(age)
```
# Fonctions NVL et COALESCE
Renvoie la valeur de la première expression qui n’est pas nulle dans une série d’expressions. Lorsqu’une valeur non nulle est trouvée, les expressions restantes de la liste ne sont pas évaluées.
NVL est identique à COALESCE. Ce sont des synonymes. Cette rubrique explique la syntaxe et contient des exemples pour les deux.
## Syntaxe
```
NVL( expression, expression, ... )
```
La syntaxe de COALESCE est identique :
```
COALESCE( expression, expression, ... )
```
Si toutes les expressions régulières sont null, le résultat est null.
Ces fonctions sont utiles lorsque vous souhaitez renvoyer une valeur secondaire lorsqu’une valeur primaire est manquante ou nulle. Par exemple, une requête peut renvoyer le premier des trois numéros de téléphone disponibles : portable, domicile ou travail. L’ordre des expressions dans la fonction détermine l’ordre d’évaluation.
## Arguments
*expression*
Expression, telle qu’un nom de colonne, à évaluer pour l’état null.
## Type de retour
AWS Clean Rooms détermine le type de données de la valeur renvoyée en fonction des expressions d'entrée. Si les types de données des expressions d’entrée n’ont pas de type commun, une erreur est renvoyée.
## Exemples
Si la liste contient des expressions entières, la fonction renvoie un entier.
```
SELECT COALESCE(NULL, 12, NULL);
coalesce
--------------
12
```
Cet exemple, qui est identique à l’exemple précédent, sauf qu’il utilise NVL, renvoie le même résultat.
```
SELECT NVL(NULL, 12, NULL);
coalesce
--------------
12
```
L’exemple suivant renvoie une chaîne de caractères.
```
SELECT COALESCE(NULL, 'AWS Clean Rooms', NULL);
coalesce
--------------
AWS Clean Rooms
```
L’exemple suivant génère une erreur car les types de données varient dans la liste d’expressions. Dans ce cas, la liste contient à la fois un type de chaîne et un type de nombre.
```
SELECT COALESCE(NULL, 'AWS Clean Rooms', 12);
ERROR: invalid input syntax for integer: "AWS Clean Rooms"
```
# NVL2 fonction
Renvoie l’une des deux valeurs selon qu’une expression spécifiée a pour valeur NULL ou NOT NULL.
## Syntaxe
```
NVL2 ( expression, not_null_return_value, null_return_value )
```
## Arguments
*expression*
Expression, telle qu’un nom de colonne, à évaluer pour l’état null.
*not\$1null\$1return\$1value*
Valeur renvoyée si *expression* a une valeur NOT NULL. La valeur *not\$1null\$1return\$1value* doit avoir le même type de données que *expression* ou être implicitement convertie en ce type de données.
*null\$1return\$1value*
Valeur renvoyée si *expression* a une valeur NULL. La valeur *null\$1return\$1value* doit avoir le même type de données que *expression* ou être implicitement convertie en ce type de données.
## Type de retour
Le type de NVL2 retour est déterminé comme suit :
+ Si *not\$1null\$1return\$1value* ou *null\$1return\$1value* a une valeur null, le type de données de l’expression non-null est renvoyé.
Si *not\$1null\$1return\$1value* et *null\$1return\$1value* n’ont pas de valeur null :
+ Si *not\$1null\$1return\$1value* et *null\$1return\$1value* ont le même type de données que le type de données renvoyé.
+ Si *not\$1null\$1return\$1value* et *null\$1return\$1value* ont des types de données numériques distincts, le type de données numériques compatible le plus petit est renvoyé.
+ Si *not\$1null\$1return\$1value* et *null\$1return\$1value* ont des types de données datetime distincts, un type de données d’horodatage est renvoyé.
+ Si *not\$1null\$1return\$1value* et *null\$1return\$1value* ont des types de données de caractères distincts, le type de données *not\$1null\$1return\$1value* est renvoyé.
+ Si *not\$1null\$1return\$1value* et *null\$1return\$1value* ont des types de données numériques et non numériques mixtes, le type de données de *not\$1null\$1return\$1value* est renvoyé.
**Important**
Dans les deux derniers cas où le type de données de *not\$1null\$1return\$1value* est renvoyé, *null\$1return\$1value* est converti implicitement en ce type de données. Si les types de données sont incompatibles, la fonction échoue.
## Notes d’utilisation
*En effet NVL2, le retour aura la valeur du paramètre *not\$1null\$1return\$1value ou null\$1return\$1value*, selon ce qui est sélectionné par la fonction, mais aura le type de données *not\$1null\$1return\$1value*.*
Par exemple, en supposant que column1 a la valeur NULL, les requêtes suivantes renverront la même valeur. Cependant, le type de données de la valeur de retour DECODE sera INTEGER et le type de données de la valeur de NVL2 retour sera VARCHAR.
```
select decode(column1, null, 1234, '2345');
select nvl2(column1, '2345', 1234);
```
## exemple
L’exemple suivant modifie quelques exemples de données, puis évalue les deux champs pour fournir des informations de contact aux utilisateurs :
```
update users set email = null where firstname = 'Aphrodite' and lastname = 'Acevedo';
select (firstname + ' ' + lastname) as name,
nvl2(email, email, phone) AS contact_info
from users
where state = 'WA'
and lastname like 'A%'
order by lastname, firstname;
name contact_info
--------------------+-------------------------------------------
Aphrodite Acevedo (555) 555-0100
Caldwell Acevedo Nunc.sollicitudin@example.ca
Quinn Adams vel@example.com
Kamal Aguilar quis@example.com
Samson Alexander hendrerit.neque@example.com
Hall Alford ac.mattis@example.com
Lane Allen et.netus@example.com
Xander Allison ac.facilisis.facilisis@example.com
Amaya Alvarado dui.nec.tempus@example.com
Vera Alvarez at.arcu.Vestibulum@example.com
Yetta Anthony enim.sit@example.com
Violet Arnold ad.litora@example.comm
August Ashley consectetuer.euismod@example.com
Karyn Austin ipsum.primis.in@example.com
Lucas Ayers at@example.com
```
# Fonction NULLIF
Compare les deux arguments et renvoie null si les arguments sont égaux. S'ils ne sont pas égaux, le premier argument est renvoyé.
## Syntaxe
L’expression NULLIF compare les deux arguments et renvoie la valeur nulle si les arguments sont égaux. S'ils ne sont pas égaux, le premier argument est renvoyé. Cette expression est l’inverse de l’expression NVL ou COALESCE.
```
NULLIF ( expression1, expression2 )
```
## Arguments
*expression1, expression2*
Colonnes ou expressions cible qui sont comparées. Le type de retour est le identique au type de la première expression.
## Exemples
Dans l’exemple suivant, la requête renvoie la chaîne `first` car les arguments ne sont pas égaux.
```
SELECT NULLIF('first', 'second');
case
-------
first
```
Dans l’exemple suivant, la requête renvoie `NULL` car les arguments littéraux de la chaîne sont égaux.
```
SELECT NULLIF('first', 'first');
case
-------
NULL
```
Dans l’exemple suivant, la requête renvoie `1` car les arguments entiers ne sont pas égaux.
```
SELECT NULLIF(1, 2);
case
-------
1
```
Dans l’exemple suivant, la requête renvoie `NULL` car les arguments entiers sont égaux.
```
SELECT NULLIF(1, 1);
case
-------
NULL
```
Dans l’exemple suivant, la requête renvoie la valeur nulle lorsque les valeurs LISTID et SALESID correspondent :
```
select nullif(listid,salesid), salesid
from sales where salesid<10 order by 1, 2 desc;
listid | salesid
--------+---------
4 | 2
5 | 4
5 | 3
6 | 5
10 | 9
10 | 8
10 | 7
10 | 6
| 1
(9 rows)
```
# Fonctions de constructeur
Une fonction de constructeur SQL est une fonction utilisée pour créer de nouvelles structures de données, telles que des tableaux ou des cartes.
Ils prennent des valeurs d'entrée et renvoient un nouvel objet de structure de données. Les fonctions de constructeur sont généralement nommées d'après le type de données qu'elles créent, tel que ARRAY ou MAP.
Les fonctions de constructeur sont différentes des fonctions scalaires ou des fonctions d'agrégation, qui opèrent sur des données existantes et renvoient une valeur unique. Les fonctions du constructeur sont utilisées pour créer de nouvelles structures de données qui peuvent ensuite être utilisées dans le cadre d'un traitement ou d'une analyse de données ultérieurs.
AWS Clean Rooms prend en charge les fonctions de constructeur suivantes :
**Topics**
+ [Fonction constructeur MAP](map_function.md)
+ [Fonction constructeur NAMED\$1STRUCT](named-struct_function.md)
+ [Fonction constructeur STRUCT](struct_function.md)
# Fonction constructeur MAP
La fonction constructeur MAP crée une carte avec les paires clé/valeur données.
Les fonctions de constructeur telles que MAP sont utiles lorsque vous devez créer de nouvelles structures de données par programmation dans vos requêtes SQL. Ils vous permettent de créer des structures de données complexes qui peuvent être utilisées dans le cadre d'un traitement ou d'une analyse de données ultérieurs.
## Syntaxe
```
map(key0, value0, key1, value1, ...)
```
## Arguments
*clé0*
Expression de n'importe quel type comparable. Toutes les *clés 0* doivent partager le type le moins commun.
*valeur0*
Expression de n'importe quel type. Toutes les *valeurs N* doivent partager le type le moins commun.
## Renvoie
*La fonction MAP renvoie une carte dont les touches sont saisies comme le type le moins courant de *clé0* et les valeurs saisies comme le type le moins courant de valeur0.*
## Exemples
L'exemple suivant crée une nouvelle carte avec deux paires clé-valeur : La clé `1.0` est associée à la valeur. `'2'` La clé `3.0` est associée à la valeur`'4'`. La carte obtenue est ensuite renvoyée en tant que sortie de l'instruction SQL.
```
SELECT map(1.0, '2', 3.0, '4');
{1.0:"2",3.0:"4"}
```
# Fonction constructeur NAMED\$1STRUCT
La fonction constructeur NAMED\$1STRUCT crée une structure avec les noms et valeurs de champs donnés.
Les fonctions de constructeur telles que NAMED\$1STRUCT sont utiles lorsque vous devez créer de nouvelles structures de données par programmation dans vos requêtes SQL. Ils vous permettent de créer des structures de données complexes, telles que des structures ou des enregistrements, qui peuvent être utilisées dans le cadre d'un traitement ou d'une analyse de données ultérieurs.
## Syntaxe
```
named_struct(name1, val1, name2, val2, ...)
```
## Arguments
*nom1*
Un champ de dénomination littéral STRING 1.
*val1*
Expression de n'importe quel type spécifiant la valeur du champ 1.
## Renvoie
*La fonction NAMED\$1STRUCT renvoie une structure dont le champ 1 correspond au type de val1.*
## Exemples
L'exemple suivant crée une nouvelle structure avec trois champs nommés : La valeur `"a"` `1` est attribuée au champ. La valeur `"b"` est affectée au champ `2.` Le champ `"c"` reçoit la valeur`3`. La structure résultante est ensuite renvoyée en tant que sortie de l'instruction SQL.
```
SELECT named_struct("a", 1, "b", 2, "c", 3);
{"a":1,"b":2,"c":3}
```
# Fonction constructeur STRUCT
La fonction constructeur STRUCT crée une structure avec les valeurs de champ données.
Les fonctions de constructeur telles que STRUCT sont utiles lorsque vous devez créer de nouvelles structures de données par programmation dans vos requêtes SQL. Ils vous permettent de créer des structures de données complexes, telles que des structures ou des enregistrements, qui peuvent être utilisées dans le cadre d'un traitement ou d'une analyse de données ultérieurs.
## Syntaxe
```
struct(col1, col2, col3, ...)
```
## Arguments
*colonel 1*
Nom de la colonne ou n’importe quelle expression valide.
## Renvoie
*La fonction STRUCT renvoie une structure dont *field1 correspond au type de expr1*.*
Si les arguments sont des références nommées, les noms sont utilisés pour nommer le champ. Sinon, les champs sont nommés *ColN*, où N est la position du champ dans la structure.
## Exemples
L'exemple suivant crée une nouvelle structure avec trois champs : La valeur 1 est attribuée au premier champ. La valeur 2 est attribuée au second champ. La valeur 3 est attribuée au troisième champ. Par défaut, les champs de la structure résultante sont nommés `col1` `col2``col3`, et en fonction de leur position dans la liste d'arguments. La structure résultante est ensuite renvoyée en tant que sortie de l'instruction SQL.
```
SELECT struct(1, 2, 3);
{"col1":1,"col2":2,"col3":3}
```
# Fonctions de formatage des types de données
À l'aide d'une fonction de formatage des types de données, vous pouvez convertir des valeurs d'un type de données à un autre. Pour chacune de ces fonctions, le premier argument est toujours la valeur à formater et le second argument contient le modèle du nouveau format.
AWS Clean Rooms Spark SQL prend en charge plusieurs fonctions de formatage des types de données.
**Topics**
+ [BASE64 fonction](base64.md)
+ [Fonction CAST](CAST_function.md)
+ [Fonction DECODE](DECODE.md)
+ [Fonction ENCODE](ENCODE.md)
+ [Fonction HEX](HEX.md)
+ [Fonction STR\$1TO\$1MAP](STR_TO_MAP.md)
+ [TO\$1CHAR](TO_CHAR.md)
+ [Fonction TO\$1DATE](TO_DATE_function.md)
+ [TO\$1NUMBER](TO_NUMBER.md)
+ [UNBASE64 fonction](unbase64.md)
+ [Fonction UNHEX](UNHEX.md)
+ [Chaînes de format datetime](FORMAT_strings.md)
+ [Chaînes de format numériques](Numeric_formating.md)
# BASE64 fonction
La BASE64 fonction convertit une expression en chaîne de base 64 à l'aide du [codage de transfert RFC2045 Base64 pour le MIME](https://datatracker.ietf.org/doc/html/rfc2045).
## Syntaxe
```
base64(expr)
```
## Arguments
*expr*
Une expression BINAIRE ou une CHAÎNE que la fonction interprétera comme BINAIRE.
## Type de retour
`STRING`
## Exemple
Pour convertir l'entrée de chaîne donnée en sa représentation codée en Base64, utilisez l'exemple suivant. Le résultat est la représentation codée en Base64 de la chaîne d'entrée « Spark SQL », qui est « u3bhcmsgu1fm ».
```
SELECT base64('Spark SQL');
U3BhcmsgU1FM
```
# Fonction CAST
La fonction CAST convertit un type de données en un autre type de données compatible. Par exemple, vous pouvez convertir une chaîne en date ou un type numérique en chaîne. CAST effectue une conversion d’exécution, ce qui signifie que la conversion ne modifie pas le type de données d’une valeur dans une table source. Elle n'est modifiée que dans le contexte de la requête.
Certains types de données nécessitent une conversion explicite en d'autres types de données à l'aide de la fonction CAST. D'autres types de données peuvent être convertis implicitement, dans le cadre d'une autre commande, sans utiliser CAST. Consultez [Compatibilité et conversion de types](s_Type_conversion.md).
## Syntaxe
Utilisez l’une de ces deux formes de syntaxes équivalentes pour convertir les expressions cast d’un type de données à un autre.
```
CAST ( expression AS type )
```
## Arguments
*expression*
Expression qui correspond à une ou plusieurs valeurs, par exemple un nom de colonne ou un littéral. La conversion de valeurs null renvoie des valeurs null. L'expression ne peut pas contenir de chaînes vides ou vides.
*type*
L'un des types de données pris en charge[Types de données](s_Supported_data_types.md), à l'exception des types de données BINARY et BINARY VARIING.
## Type de retour
CAST renvoie le type de données spécifié par l’argument *type*.
**Note**
AWS Clean Rooms renvoie une erreur si vous essayez d'effectuer une conversion problématique, telle qu'une conversion DECIMAL qui perd en précision, comme suit :
```
select 123.456::decimal(2,1);
```
ou une conversion INTEGER qui entraîne un dépassement de capacité :
```
select 12345678::smallint;
```
## Exemples
Les deux requêtes suivantes sont équivalentes. Toutes deux convertissent une valeur décimale en un nombre entier :
```
select cast(pricepaid as integer)
from sales where salesid=100;
pricepaid
-----------
162
(1 row)
```
```
select pricepaid::integer
from sales where salesid=100;
pricepaid
-----------
162
(1 row)
```
Ce qui suit produit un résultat similaire. Il ne nécessite pas d’exemples de données pour s’exécuter :
```
select cast(162.00 as integer) as pricepaid;
pricepaid
-----------
162
(1 row)
```
Dans cet exemple, les valeurs d’une colonne d’horodatage sont converties en dates, ce qui entraîne la suppression de l’horodatage de chaque résultat :
```
select cast(saletime as date), salesid
from sales order by salesid limit 10;
saletime | salesid
-----------+---------
2008-02-18 | 1
2008-06-06 | 2
2008-06-06 | 3
2008-06-09 | 4
2008-08-31 | 5
2008-07-16 | 6
2008-06-26 | 7
2008-07-10 | 8
2008-07-22 | 9
2008-08-06 | 10
(10 rows)
```
Si vous n’avez pas utilisé CAST comme illustré dans l’exemple précédent, les résultats incluraient l’heure : *2008-02-18 02:36:48*.
La requête suivante convertit des données de caractères variables en date. Elle ne nécessite pas d’exemples de données pour s’exécuter.
```
select cast('2008-02-18 02:36:48' as date) as mysaletime;
mysaletime
--------------------
2008-02-18
(1 row)
```
Dans cet exemple, les valeurs d’une colonne de dates sont converties en horodatages :
```
select cast(caldate as timestamp), dateid
from date order by dateid limit 10;
caldate | dateid
--------------------+--------
2008-01-01 00:00:00 | 1827
2008-01-02 00:00:00 | 1828
2008-01-03 00:00:00 | 1829
2008-01-04 00:00:00 | 1830
2008-01-05 00:00:00 | 1831
2008-01-06 00:00:00 | 1832
2008-01-07 00:00:00 | 1833
2008-01-08 00:00:00 | 1834
2008-01-09 00:00:00 | 1835
2008-01-10 00:00:00 | 1836
(10 rows)
```
Dans un cas comme dans l'exemple précédent, vous pouvez obtenir un contrôle supplémentaire sur le formatage de sortie en utilisant[TO\$1CHAR](TO_CHAR.md).
Dans cet exemple, un nombre entier est converti en chaîne de caractères :
```
select cast(2008 as char(4));
bpchar
--------
2008
```
Dans cet exemple, une valeur DECIMAL(6,3) est convertie en valeur DECIMAL(4,1) :
```
select cast(109.652 as decimal(4,1));
numeric
---------
109.7
```
Cet exemple montre une expression plus complexe. La colonne PRICEPAID (colonne DECIMAL(8,2)) de la table SALES est convertie en une colonne DECIMAL(38,2) et les valeurs sont multipliées par 100000000000000000000 :
```
select salesid, pricepaid::decimal(38,2)*100000000000000000000
as value from sales where salesid<10 order by salesid;
salesid | value
---------+----------------------------
1 | 72800000000000000000000.00
2 | 7600000000000000000000.00
3 | 35000000000000000000000.00
4 | 17500000000000000000000.00
5 | 15400000000000000000000.00
6 | 39400000000000000000000.00
7 | 78800000000000000000000.00
8 | 19700000000000000000000.00
9 | 59100000000000000000000.00
(9 rows)
```
# Fonction DECODE
La fonction DECODE est l'équivalent de la fonction ENCODE, qui est utilisée pour convertir une chaîne en format binaire à l'aide d'un codage de caractères spécifique. La fonction DECODE prend les données binaires et les reconvertit en un format de chaîne lisible en utilisant le codage de caractères spécifié.
Cette fonction est utile lorsque vous devez travailler avec des données binaires stockées dans une base de données et les présenter dans un format lisible par l'homme, ou lorsque vous devez convertir des données entre différents codages de caractères.
## Syntaxe
```
decode(expr, charset)
```
## Arguments
*expr*
Expression BINAIRE codée dans un jeu de caractères.
*jeu de caractères*
Expression STRING.
Encodages de jeux de caractères pris en charge (sans distinction majuscules/minuscules) :`'US-ASCII'`,`'ISO-8859-1'`, `'UTF-8'``'UTF-16BE'`, `'UTF-16LE'` et. `'UTF-16'`
## Type de retour
La fonction DECODE renvoie une chaîne.
## Exemple
L'exemple suivant contient une table appelée `messages` avec une colonne appelée `message_text` qui stocke les données des messages dans un format binaire à l'aide du codage de caractères UTF-8. La fonction DECODE reconvertit les données binaires en un format de chaîne lisible. Le résultat de cette requête est le texte lisible du message stocké dans la table des messages, avec l'ID`123`, converti du format binaire en chaîne à l'aide du `'utf-8'` codage.
```
SELECT decode(message_text, 'utf-8') AS message
FROM messages
WHERE message_id = 123;
```
# Fonction ENCODE
La fonction ENCODE est utilisée pour convertir une chaîne en sa représentation binaire à l'aide d'un codage de caractères spécifié.
Cette fonction est utile lorsque vous devez travailler avec des données binaires ou lorsque vous devez effectuer une conversion entre différents codages de caractères. Par exemple, vous pouvez utiliser la fonction ENCODE lorsque vous stockez des données dans une base de données qui nécessite un stockage binaire ou lorsque vous devez transférer des données entre des systèmes utilisant des codages de caractères différents.
## Syntaxe
```
encode(str, charset)
```
## Arguments
*str*
Expression STRING à encoder.
*jeu de caractères*
Expression STRING spécifiant le codage.
Encodages de jeux de caractères pris en charge (sans distinction majuscules/minuscules) :`'US-ASCII'`,`'ISO-8859-1'`, `'UTF-8'``'UTF-16BE'`, `'UTF-16LE'` et. `'UTF-16'`
## Type de retour
La fonction ENCODE renvoie un BINARY.
## Exemple
L'exemple suivant convertit la chaîne en sa représentation binaire `'abc'` à l'aide du `'utf-8'` codage, ce qui, dans ce cas, renvoie la chaîne d'origine. Cela est dû au fait que le `'utf-8'` codage est un codage de caractères à largeur variable qui peut représenter l'ensemble du jeu de caractères ASCII (y compris les lettres `'a'``'b'`, et`'c'`) en utilisant un seul octet par caractère. Par conséquent, la représentation binaire de `'abc'` l'utilisation `'utf-8'` est la même que celle de la chaîne d'origine.
```
SELECT encode('abc', 'utf-8');
abc
```
# Fonction HEX
La fonction HEX convertit une valeur numérique (un entier ou un nombre à virgule flottante) en sa représentation sous forme de chaîne hexadécimale correspondante.
L'hexadécimal est un système numérique qui utilise 16 symboles distincts (0-9 et A-F) pour représenter des valeurs numériques. Il est couramment utilisé en informatique et en programmation pour représenter des données binaires dans un format plus compact et lisible par l'homme.
## Syntaxe
```
hex(expr)
```
## Arguments
*expr*
Expression BIGINT, BINARY ou STRING.
## Type de retour
HEX renvoie une chaîne. La fonction renvoie la représentation hexadécimale de l'argument.
## Exemple
L'exemple suivant prend la valeur entière 17 en entrée et lui applique la fonction HEX (). La sortie est`11`, qui est la représentation hexadécimale de la valeur d'entrée`17`.
```
SELECT hex(17);
11
```
L'exemple suivant convertit la chaîne `'Spark_SQL'` en sa représentation hexadécimale. La sortie est`537061726B2053514C`, qui est la représentation hexadécimale de la chaîne d'entrée`'Spark_SQL'`.
```
SELECT hex('Spark_SQL');
537061726B2053514C
```
Dans cet exemple, la chaîne « Spark\$1SQL » est convertie comme suit :
+ 'S' -> 53
+ « p » -> 70
+ « a » -> 61
+ 'r' -> 72 '
+ k' -> 6 B
+ « \$1 » -> 20
+ 'S' -> 53
+ « Q » -> 51
+ « L' » -> 4C
La concaténation de ces valeurs hexadécimales donne le résultat final « ». `537061726B2053514C"`
# Fonction STR\$1TO\$1MAP
La fonction STR\$1TO\$1MAP est une fonction de conversion. string-to-map Il convertit une représentation sous forme de chaîne d'une carte (ou d'un dictionnaire) en une structure de données cartographique réelle.
Cette fonction est utile lorsque vous devez travailler avec des structures de données cartographiques en SQL, mais les données sont initialement stockées sous forme de chaîne. En convertissant la représentation sous forme de chaîne en une carte réelle, vous pouvez ensuite effectuer des opérations et des manipulations sur les données cartographiques.
## Syntaxe
```
str_to_map(text[, pairDelim[, keyValueDelim]])
```
## Arguments
*texte*
Expression STRING qui représente la carte.
*Pair Delim*
Un littéral STRING facultatif qui indique comment séparer les entrées. La valeur par défaut est une virgule ()`','`.
*keyValueDelim*
Un littéral STRING facultatif qui indique comment séparer chaque paire clé-valeur. La valeur par défaut est deux points (`':'`).
## Type de retour
La fonction STR\$1TO\$1MAP renvoie une carte de type STRING pour les clés et les valeurs. *PairDelim et PairDelim *keyValueDelim**sont tous deux traités comme des expressions régulières.
## Exemple
L'exemple suivant prend la chaîne d'entrée et les deux arguments du séparateur, et convertit la représentation sous forme de chaîne en une structure de données cartographique réelle. Dans cet exemple spécifique, la chaîne d'entrée `'a:1,b:2,c:3'` représente une carte avec les paires clé-valeur suivantes : `'a'` est la clé et `'1'` est la valeur. `'b'`est la clé, et `'2'` c'est la valeur. `'c'`est la clé, et `'3'` c'est la valeur. Le `','` délimiteur est utilisé pour séparer les paires clé-valeur, et le `':'` délimiteur est utilisé pour séparer la clé et la valeur au sein de chaque paire. Le résultat de cette requête est : `{"a":"1","b":"2","c":"3"}` Il s'agit de la structure de données cartographiques résultante`'a'`, où les clés sont `'b'``'c'`, et, et les valeurs correspondantes sont `'1'``'2'`, et`'3'`.
```
SELECT str_to_map('a:1,b:2,c:3', ',', ':');
{"a":"1","b":"2","c":"3"}
```
L'exemple suivant montre que la fonction STR\$1TO\$1MAP s'attend à ce que la chaîne d'entrée soit dans un format spécifique, avec les paires clé-valeur correctement délimitées. Si la chaîne d'entrée ne correspond pas au format attendu, la fonction tentera tout de même de créer une carte, mais les valeurs obtenues risquent de ne pas correspondre aux attentes.
```
SELECT str_to_map('a');
{"a":null}
```
# TO\$1CHAR
TO\$1CHAR convertit un horodatage ou une expression numérique en un format de données de chaînes de caractères.
## Syntaxe
```
TO_CHAR (timestamp_expression | numeric_expression , 'format')
```
## Arguments
*timestamp\$1expression*
Expression qui se traduit par une valeur de type TIMESTAMP ou TIMESTAMPTZ ou par une valeur qui peut être implicitement convertie en un horodatage.
*numeric\$1expression*
Expression qui se traduit par une valeur de type de données numérique ou par une valeur qui peut être implicitement convertie en un type numérique. Pour de plus amples informations, veuillez consulter [Types numériques](Numeric_types.md). TO\$1CHAR insère un espace à gauche de la chaîne numérique.
TO\$1CHAR ne prend pas en charge les valeurs DECIMAL 128 bits.
*format*
Format de la nouvelle valeur. Pour connaître les formats valides, consultez [Chaînes de format datetime](FORMAT_strings.md) et [Chaînes de format numériques](Numeric_formating.md).
## Type de retour
VARCHAR
## Exemples
L’exemple suivant convertit un horodatage en une valeur contenant la date et l’heure dans un format comprenant le nom du mois rempli jusqu’à neuf caractères, le nom du jour de la semaine et le numéro du jour du mois.
```
select to_char(timestamp '2009-12-31 23:15:59', 'MONTH-DY-DD-YYYY HH12:MIPM');
to_char
-------------------------
DECEMBER -THU-31-2009 11:15PM
```
L’exemple suivant convertit un horodatage en une valeur avec le numéro du jour de l’année.
```
select to_char(timestamp '2009-12-31 23:15:59', 'DDD');
to_char
-------------------------
365
```
L’exemple suivant convertit un horodatage en un numéro de jour de la semaine ISO.
```
select to_char(timestamp '2022-05-16 23:15:59', 'ID');
to_char
-------------------------
1
```
L’exemple suivant extrait le nom du mois d’une date.
```
select to_char(date '2009-12-31', 'MONTH');
to_char
-------------------------
DECEMBER
```
L’exemple suivant convertit chaque valeur STARTTIME de la table EVENT en une chaîne composée d’heures, de minutes et de secondes.
```
select to_char(starttime, 'HH12:MI:SS')
from event where eventid between 1 and 5
order by eventid;
to_char
----------
02:30:00
08:00:00
02:30:00
02:30:00
07:00:00
(5 rows)
```
L’exemple suivant convertit une valeur d’horodatage complète en un format différent.
```
select starttime, to_char(starttime, 'MON-DD-YYYY HH12:MIPM')
from event where eventid=1;
starttime | to_char
---------------------+---------------------
2008-01-25 14:30:00 | JAN-25-2008 02:30PM
(1 row)
```
L’exemple suivant convertit un littéral d’horodatage en une chaîne de caractères.
```
select to_char(timestamp '2009-12-31 23:15:59','HH24:MI:SS');
to_char
----------
23:15:59
(1 row)
```
L’exemple suivant convertit un nombre en chaîne de caractères avec le signe moins à la fin.
```
select to_char(-125.8, '999D99S');
to_char
---------
125.80-
(1 row)
```
L’exemple suivant convertit un nombre en chaîne de caractères avec le symbole de la devise.
```
select to_char(-125.88, '$S999D99');
to_char
---------
$-125.88
(1 row)
```
L’exemple suivant convertit un nombre en une chaîne de caractères.
```
select to_char(-125.88, '$999D99PR');
to_char
---------
$<125.88>
(1 row)
```
L’exemple suivant convertit un nombre en chaîne numérale romaine.
```
select to_char(125, 'RN');
to_char
---------
CXXV
(1 row)
```
L’exemple suivant affiche le jour de la semaine.
```
SELECT to_char(current_timestamp, 'FMDay, FMDD HH12:MI:SS');
to_char
-----------------------
Wednesday, 31 09:34:26
```
L’exemple suivant affiche le suffixe ordinal d’un nombre.
```
SELECT to_char(482, '999th');
to_char
-----------------------
482nd
```
L’exemple suivant soustraie la commission du prix d’achat de la table des ventes. La différence est ensuite arrondie et convertie en chiffres romains, comme indiqué dans la `to_char` colonne :
```
select salesid, pricepaid, commission, (pricepaid - commission)
as difference, to_char(pricepaid - commission, 'rn') from sales
group by sales.pricepaid, sales.commission, salesid
order by salesid limit 10;
salesid | pricepaid | commission | difference | to_char
---------+-----------+------------+------------+-----------------
1 | 728.00 | 109.20 | 618.80 | dcxix
2 | 76.00 | 11.40 | 64.60 | lxv
3 | 350.00 | 52.50 | 297.50 | ccxcviii
4 | 175.00 | 26.25 | 148.75 | cxlix
5 | 154.00 | 23.10 | 130.90 | cxxxi
6 | 394.00 | 59.10 | 334.90 | cccxxxv
7 | 788.00 | 118.20 | 669.80 | dclxx
8 | 197.00 | 29.55 | 167.45 | clxvii
9 | 591.00 | 88.65 | 502.35 | dii
10 | 65.00 | 9.75 | 55.25 | lv
(10 rows)
```
L'exemple suivant ajoute le symbole monétaire aux valeurs de différence indiquées dans la `to_char` colonne :
```
select salesid, pricepaid, commission, (pricepaid - commission)
as difference, to_char(pricepaid - commission, 'l99999D99') from sales
group by sales.pricepaid, sales.commission, salesid
order by salesid limit 10;
salesid | pricepaid | commission | difference | to_char
--------+-----------+------------+------------+------------
1 | 728.00 | 109.20 | 618.80 | $ 618.80
2 | 76.00 | 11.40 | 64.60 | $ 64.60
3 | 350.00 | 52.50 | 297.50 | $ 297.50
4 | 175.00 | 26.25 | 148.75 | $ 148.75
5 | 154.00 | 23.10 | 130.90 | $ 130.90
6 | 394.00 | 59.10 | 334.90 | $ 334.90
7 | 788.00 | 118.20 | 669.80 | $ 669.80
8 | 197.00 | 29.55 | 167.45 | $ 167.45
9 | 591.00 | 88.65 | 502.35 | $ 502.35
10 | 65.00 | 9.75 | 55.25 | $ 55.25
(10 rows)
```
L’exemple suivant répertorie le siècle au cours duquel chaque vente a été effectuée.
```
select salesid, saletime, to_char(saletime, 'cc') from sales
order by salesid limit 10;
salesid | saletime | to_char
---------+---------------------+---------
1 | 2008-02-18 02:36:48 | 21
2 | 2008-06-06 05:00:16 | 21
3 | 2008-06-06 08:26:17 | 21
4 | 2008-06-09 08:38:52 | 21
5 | 2008-08-31 09:17:02 | 21
6 | 2008-07-16 11:59:24 | 21
7 | 2008-06-26 12:56:06 | 21
8 | 2008-07-10 02:12:36 | 21
9 | 2008-07-22 02:23:17 | 21
10 | 2008-08-06 02:51:55 | 21
(10 rows)
```
L’exemple suivant convertit chaque valeur STARTTIME de la table EVENT en une chaîne qui se compose d’heures, de minutes, de secondes et d’un fuseau horaire.
```
select to_char(starttime, 'HH12:MI:SS TZ')
from event where eventid between 1 and 5
order by eventid;
to_char
----------
02:30:00 UTC
08:00:00 UTC
02:30:00 UTC
02:30:00 UTC
07:00:00 UTC
(5 rows)
(10 rows)
```
L’exemple suivant illustre la mise en forme des secondes, millisecondes et microsecondes.
```
select sysdate,
to_char(sysdate, 'HH24:MI:SS') as seconds,
to_char(sysdate, 'HH24:MI:SS.MS') as milliseconds,
to_char(sysdate, 'HH24:MI:SS:US') as microseconds;
timestamp | seconds | milliseconds | microseconds
--------------------+----------+--------------+----------------
2015-04-10 18:45:09 | 18:45:09 | 18:45:09.325 | 18:45:09:325143
```
# Fonction TO\$1DATE
TO\$1DATE convertit une date représentée par une chaîne de caractères en un type de données DATE.
## Syntaxe
```
TO_DATE (date_str)
```
```
TO_DATE (date_str, format)
```
## Arguments
*date\$1str*
Chaîne de date ou type de données pouvant être converti en chaîne de date.
*format*
Chaîne littérale qui correspond aux modèles de date/heure de Spark. Pour les modèles de date/heure valides, voir Modèles de [date/heure pour le formatage et](https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html) l'analyse syntaxique.
## Type de retour
TO\$1DATE renvoie une DATE, selon la valeur de *format*.
Si la conversion au *format* échoue, une erreur est renvoyée.
## Exemples
L’instruction SQL suivante convertit la date `02 Oct 2001` en type de données de date.
```
select to_date('02 Oct 2001', 'dd MMM yyyy');
to_date
------------
2001-10-02
(1 row)
```
L’instruction SQL suivante convertit la chaîne `20010631` en date.
```
select to_date('20010631', 'yyyyMMdd');
```
L’instruction SQL suivante convertit la chaîne `20010631` en date :
```
to_date('20010631', 'YYYYMMDD', TRUE);
```
Le résultat est une valeur nulle car le mois de juin ne compte que 30 jours.
```
to_date
------------
NULL
```
# TO\$1NUMBER
TO\$1NUMBER convertit une chaîne en une valeur numérique (décimale).
## Syntaxe
```
to_number(string, format)
```
## Arguments
*string*
Chaîne à convertir. Le format doit être une valeur littérale.
*format*
Le deuxième argument est une chaîne de format qui indique comment la chaîne de caractères doit être analysée afin de créer la valeur numérique. Par exemple, le format `'99D999'` spécifie que la chaîne à convertir se compose de cinq chiffres, avec la virgule à la troisième position. Par exemple, `to_number('12.345','99D999')` renvoie `12.345` comme une valeur numérique. Pour obtenir la liste des formats valides, consultez [Chaînes de format numériques](Numeric_formating.md).
## Type de retour
TO\$1NUMBER renvoie un nombre DECIMAL.
Si la conversion au *format* échoue, une erreur est renvoyée.
## Exemples
L’exemple suivant convertit la chaîne `12,454.8-` en un nombre :
```
select to_number('12,454.8-', '99G999D9S');
to_number
-----------
-12454.8
```
L’exemple suivant convertit la chaîne `$ 12,454.88` en un nombre :
```
select to_number('$ 12,454.88', 'L 99G999D99');
to_number
-----------
12454.88
```
L’exemple suivant convertit la chaîne `$ 2,012,454.88` en un nombre :
```
select to_number('$ 2,012,454.88', 'L 9,999,999.99');
to_number
-----------
2012454.88
```
# UNBASE64 fonction
La UNBASE64 fonction convertit un argument d'une chaîne de base 64 en binaire.
Le codage Base64 est couramment utilisé pour représenter des données binaires (telles que des images, des fichiers ou des informations cryptées) dans un format textuel sûr pour la transmission sur différents canaux de communication (tels que le courrier électronique, les paramètres d'URL ou le stockage de base de données).
La UNBASE64 fonction permet d'inverser ce processus et de récupérer les données binaires d'origine. Ce type de fonctionnalité peut être utile dans les scénarios où vous devez travailler avec des données codées au format Base64, par exemple lors de l'intégration à des systèmes externes ou APIs lorsque vous utilisez Base64 comme mécanisme de transfert de données.
## Syntaxe
```
unbase64(expr)
```
## Arguments
*expr*
Expression STRING au format base64.
## Type de retour
`BINARY`
## Exemple
Dans l'exemple suivant, la chaîne codée en Base64 `'U3BhcmsgU1FM'` est reconvertie en chaîne d'origine. `'Spark SQL'`
```
SELECT unbase64('U3BhcmsgU1FM');
Spark SQL
```
# Fonction UNHEX
La fonction UNHEX reconvertit une chaîne hexadécimale en sa représentation sous forme de chaîne d'origine.
Cette fonction peut être utile dans les scénarios où vous devez travailler avec des données stockées ou transmises dans un format hexadécimal, et vous devez restaurer la représentation de chaîne d'origine pour un traitement ou un affichage ultérieurs.
La fonction UNHEX est le pendant de la fonction [HEX](HEX.md).
## Syntaxe
```
unhex(expr)
```
## Arguments
*expr*
Expression de type STRING composée de caractères hexadécimaux.
## Type de retour
UNHEX renvoie un BINARY.
Si la longueur de *expr* est impaire, le premier caractère est supprimé et le résultat est complété par un octet nul. Si *expr* contient des caractères non hexadécimaux, le résultat est NULL.
## Exemple
L'exemple suivant reconvertit une chaîne hexadécimale en sa représentation sous forme de chaîne d'origine en utilisant conjointement les fonctions UNHEX () et DECODE (). La première partie de la requête utilise la fonction UNHEX () pour convertir la chaîne hexadécimale '537061726B2053514C' en sa représentation binaire. La deuxième partie de la requête utilise la fonction DECODE () pour reconvertir les données binaires obtenues par la fonction UNHEX () en chaîne, en utilisant le codage de caractères « UTF-8 ». Le résultat de la requête est la chaîne originale 'Spark\$1SQL' qui a été convertie en hexadécimal puis redevenue une chaîne.
```
SELECT decode(unhex('537061726B2053514C'), 'UTF-8');
Spark SQL
```
# Chaînes de format datetime
Vous pouvez utiliser des modèles de date/heure dans les scénarios courants suivants :
+ Lorsque vous travaillez avec des sources de données CSV et JSON pour analyser et formater du contenu date/heure
+ Lors de la conversion entre des types de chaînes et des types de date ou d'horodatage à l'aide de fonctions telles que :
+ horodatage unix
+ date\$1format
+ to\$1unix\$1timestamp
+ from\$1unixtime
+ to\$1date
+ to\$1timestamp
+ from\$1utc\$1timestamp
+ to\$1utc\$1timestamp
Utilisez les lettres types du tableau suivant pour l'analyse et le formatage de la date et de l'horodatage.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/clean-rooms/latest/sql-reference/FORMAT_strings.html)
Le nombre de lettres du modèle détermine le type de format :
Format du texte
+ Utilisez 1 à 3 lettres pour la forme abrégée (par exemple, « Mon » pour le lundi)
+ Utilisez exactement 4 lettres pour le formulaire complet (par exemple, « lundi »)
+ N'utilisez pas 5 lettres ou plus, cela provoquerait une erreur
Format numérique (n)
+ La valeur n représente le nombre maximum de lettres autorisées
+ Pour les modèles à lettre unique :
+ La sortie utilise un minimum de chiffres sans remplissage
+ Pour plusieurs modèles de lettres :
+ La sortie est complétée par des zéros pour correspondre à la largeur du nombre de lettres
+ Lors de l'analyse, l'entrée doit contenir le nombre exact de chiffres
Format numérique/texte
+ Pour 3 lettres ou plus, suivez les règles du format de texte
+ Pour réduire le nombre de lettres, suivez les règles relatives au format numérique
Format de fraction
+ Utilisez 1 à 9 caractères « S » (par exemple, SSSSSS)
+ Pour l'analyse syntaxique :
+ Acceptez les fractions comprises entre 1 et le nombre de caractères S
+ Pour le formatage :
+ Bloc avec des zéros correspondant au nombre de caractères S
+ Supporte jusqu'à 6 chiffres pour une précision de l'ordre de la microseconde
+ Peut analyser des nanosecondes mais tronque des chiffres supplémentaires
Format de l'année
+ Le nombre de lettres définit la largeur de champ minimale pour le rembourrage
+ Pour deux lettres :
+ Imprime les deux derniers chiffres
+ Analyse les années entre 2000 et 2099
+ Pour moins de quatre lettres (sauf deux) :
+ Affiche le signe uniquement pour les années négatives
+ N'utilisez pas 7 lettres ou plus, cela provoquerait une erreur
Format du mois
+ Utilisez « M » pour le formulaire standard ou « L » pour le formulaire autonome
+ « M » ou « L » simple :
+ Affiche les numéros des mois 1 à 12 sans rembourrage
+ « MM » ou « LL » :
+ Affiche les numéros des mois 01-12 avec rembourrage
+ « MAMAN » :
+ Affiche le nom abrégé du mois sous forme standard
+ Doit faire partie d'un schéma de date complet
+ « TOUT LE MONDE » :
+ Affiche le nom abrégé du mois sous forme autonome
+ À utiliser pour le formatage mensuel uniquement
+ « MMMM » :
+ Affiche le nom complet du mois sous forme standard
+ À utiliser pour les dates et les horodatages
+ « TOUT LE MONDE » :
+ Affiche le nom complet du mois sous forme autonome
+ À utiliser pour le formatage mensuel uniquement
Formats de fuseau horaire
+ Du matin au soir : utilisez une seule lettre
+ ID de zone (V) : utilisez 2 lettres uniquement
+ Noms de zone (z) :
+ 1 à 3 lettres : affiche le nom court
+ 4 lettres : affiche le nom complet
+ N'utilisez pas 5 lettres ou plus
Formats de décalage
+ X et x :
+ 1 lettre : affiche l'heure (\$101) ou l'heure/minute (\$10130)
+ 2 lettres : affiche les heures et les minutes sans deux points (\$10130)
+ 3 lettres : affiche les heures et les minutes avec deux points (\$1 01:30)
+ 4 lettres : Afficher hour-minute-second sans deux points (\$1013015)
+ 5 lettres : Afficher hour-minute-second avec deux points (\$1 01:30:15)
+ X utilise « Z » pour un décalage nul
+ x utilise « \$100 », « \$10000 » ou « \$1 00:00 » pour un décalage nul
+ O:
+ 1 lettre : affiche la forme abrégée (GMT\$18)
+ 4 lettres : affiche le formulaire complet (GMT\$1 08:00)
+ Z :
+ 1 à 3 lettres : affiche les heures et les minutes sans deux points (\$10130)
+ 4 lettres : affiche le formulaire localisé complet
+ 5 lettres : Indique hour-minute-second avec deux points
Sections facultatives
+ Utilisez des crochets [] pour marquer le contenu facultatif
+ Vous pouvez imbriquer des sections facultatives
+ Toutes les données valides apparaissent dans la sortie
+ La saisie peut omettre des sections facultatives entières
**Note**
Les symboles « E », « F », « q » et « Q » ne fonctionnent que pour le formatage de la date et de l'heure (comme date\$1format). Ne les utilisez pas pour l'analyse de la date et de l'heure (comme to\$1timestamp).
# Chaînes de format numériques
Les chaînes de format numérique suivantes s'appliquent à des fonctions telles que TO\$1NUMBER et TO\$1CHAR.
+ Pour des exemples de formatage de chaînes sous forme de nombres, consultez [TO\$1NUMBER](TO_NUMBER.md).
+ Pour des exemples de formatage de nombres sous forme de chaînes, consultez [TO\$1CHAR](TO_CHAR.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/clean-rooms/latest/sql-reference/Numeric_formating.html)
# Fonctions de date et d’heure
Les fonctions de date et d'heure vous permettent d'effectuer un large éventail d'opérations sur les données de date et d'heure, telles que l'extraction de parties d'une date, le calcul des dates, le formatage des dates et des heures et l'utilisation de la date et de l'heure actuelles. Ces fonctions sont essentielles pour les tâches telles que l'analyse des données, le reporting et la manipulation de données impliquant des données temporelles.
AWS Clean Rooms prend en charge les fonctions de date et d'heure suivantes :
**Topics**
+ [Fonction ADD\$1MONTHS](ADD_MONTHS.md)
+ [Fonction CONVERT\$1TIMEZONE](s_CONVERT_TIMEZONE.md)
+ [Fonction CURRENT\$1DATE](CURRENT_DATE_function.md)
+ [Fonction CURRENT\$1TIMESTAMP](CURRENT_TIMESTAMP.md)
+ [Fonction DATE\$1ADD](DATE_ADD_function.md)
+ [Fonction DATE\$1DIFF](DATE_DIFF_function.md)
+ [Fonction DATE\$1PART](DATE_PART_function.md)
+ [Fonction DATE\$1TRUNC](DATE_TRUNC.md)
+ [Fonction DAY](DAY.md)
+ [Fonction DAYOFMONTH](DAYOFMONTH.md)
+ [Fonction DAYOFWEEK](DAYOFWEEK.md)
+ [Fonction DAYOFYEAR](DAYOFYEAR.md)
+ [Fonction EXTRACT](EXTRACT_function.md)
+ [Fonction FROM\$1UTC\$1TIMESTAMP](FROM_UTC_TIMESTAMP.md)
+ [Fonction HOUR](HOUR.md)
+ [Fonction MINUTE](MINUTE.md)
+ [Fonction MONTH](MONTH.md)
+ [DEUXIÈME fonction](SECOND.md)
+ [Fonction TIMESTAMP](TIMESTAMP.md)
+ [Fonction TO\$1TIMESTAMP](TO_TIMESTAMP.md)
+ [Fonction YEAR](YEAR.md)
+ [Parties de date pour les fonctions de date ou d'horodatage](Dateparts_for_datetime_functions.md)
# Fonction ADD\$1MONTHS
ADD\$1MONTHS ajoute le nombre de mois spécifié à une date, à une valeur d’horodatage ou à une expression. La fonction [DATE\$1ADD](DATE_ADD_function.md) fournit une fonctionnalité similaire.
## Syntaxe
```
ADD_MONTHS( {date | timestamp}, integer)
```
## Arguments
*date* \$1 *timestamp*
Colonne date ou timestamp ou expression qui convertit implicitement en un horodatage ou une date. Si la date est le dernier jour du mois, ou si le mois résultant est plus court, la fonction renvoie le dernier jour du mois dans le résultat. Pour les autres dates, le résultat contient le même nombre de jours que l’expression de date.
*integer*
Nombre entier positif ou négatif. Utilisez un nombre négatif pour soustraire des mois à partir de dates.
## Type de retour
TIMESTAMP
## Exemple
La requête suivante utilise la fonction ADD\$1MONTHS à l’intérieur d’une fonction TRUNC. La fonction TRUNC supprime l’heure du jour des résultats de ADD\$1MONTHS. La fonction ADD\$1MONTHS ajoute 12 mois à chaque valeur de la colonne CALDATE.
```
select distinct trunc(add_months(caldate, 12)) as calplus12,
trunc(caldate) as cal
from date
order by 1 asc;
calplus12 | cal
------------+------------
2009-01-01 | 2008-01-01
2009-01-02 | 2008-01-02
2009-01-03 | 2008-01-03
...
(365 rows)
```
Les exemples suivants illustrent le comportement lorsque la fonction ADD\$1MONTHS opère sur des dates comportant des mois avec un nombre de jours différent.
```
select add_months('2008-03-31',1);
add_months
---------------------
2008-04-30 00:00:00
(1 row)
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
(1 row)
```
# Fonction CONVERT\$1TIMEZONE
CONVERT\$1TIMEZONE convertit un horodatage d’un fuseau horaire à un autre. La fonction s’ajuste automatiquement pour l’heure d’été.
## Syntaxe
```
CONVERT_TIMEZONE ( ['source_timezone',] 'target_timezone', 'timestamp')
```
## Arguments
*source\$1timezone*
(Facultatif) Fuseau horaire de l’horodatage actuel. La valeur par défaut est UTC.
*target\$1timezone*
Fuseau horaire du nouvel horodatage.
*timestamp*
Colonne timestamp ou expression qui convertit implicitement en un horodatage.
## Type de retour
TIMESTAMP
## Exemples
L’exemple suivant convertit la valeur d’horodatage du fuseau horaire UTC par défaut en HNP.
```
select convert_timezone('PST', '2008-08-21 07:23:54');
convert_timezone
------------------------
2008-08-20 23:23:54
```
L’exemple suivant convertit la valeur d’horodatage dans la colonne LISTTIME du fuseau horaire UTC par défaut en HNP. Même si l’horodatage est à l’heure d’été, il est converti en heure normale, car le fuseau horaire cible est spécifié comme abréviation (PST).
```
select listtime, convert_timezone('PST', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+-------------------
2008-08-24 09:36:12 2008-08-24 01:36:12
```
L'exemple suivant convertit une colonne d'horodatage LISTTIME du fuseau horaire UTC par défaut en fuseau horaire. US/Pacific Le fuseau horaire cible utilise un nom de fuseau horaire, et l’horodatage se situe pendant la période l’heure d’été, donc la fonction renvoie l’heure.
```
select listtime, convert_timezone('US/Pacific', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+---------------------
2008-08-24 09:36:12 | 2008-08-24 02:36:12
```
L’exemple suivant convertit une chaîne d’horodatage de l’EST à PST :
```
select convert_timezone('EST', 'PST', '20080305 12:25:29');
convert_timezone
-------------------
2008-03-05 09:25:29
```
L’exemple suivant convertit un horodatage à l’heure normale de l’est des États-Unis, car le fuseau horaire cible utilise un nom de fuseau horaire (Amérique/New\$1York) et que l’horodatage est à l’heure normale.
```
select convert_timezone('America/New_York', '2013-02-01 08:00:00');
convert_timezone
---------------------
2013-02-01 03:00:00
(1 row)
```
L’exemple suivant convertit un horodatage à l’heure d’été de l’est des États-Unis, car le fuseau horaire cible utilise un nom de fuseau horaire (Amérique/New\$1York) et que l’horodatage est à l’heure d’été.
```
select convert_timezone('America/New_York', '2013-06-01 08:00:00');
convert_timezone
---------------------
2013-06-01 04:00:00
(1 row)
```
L’exemple suivant illustre l’utilisation des décalages.
```
SELECT CONVERT_TIMEZONE('GMT','NEWZONE +2','2014-05-17 12:00:00') as newzone_plus_2,
CONVERT_TIMEZONE('GMT','NEWZONE-2:15','2014-05-17 12:00:00') as newzone_minus_2_15,
CONVERT_TIMEZONE('GMT','America/Los_Angeles+2','2014-05-17 12:00:00') as la_plus_2,
CONVERT_TIMEZONE('GMT','GMT+2','2014-05-17 12:00:00') as gmt_plus_2;
newzone_plus_2 | newzone_minus_2_15 | la_plus_2 | gmt_plus_2
---------------------+---------------------+---------------------+---------------------
2014-05-17 10:00:00 | 2014-05-17 14:15:00 | 2014-05-17 10:00:00 | 2014-05-17 10:00:00
(1 row)
```
# Fonction CURRENT\$1DATE
CURRENT\$1DATE renvoie une date dans le fuseau horaire de la session en cours (UTC par défaut) au format par défaut :. YYYY-MM-DD
**Note**
CURRENT\$1DATE renvoie la date de début de la transaction en cours, pas le début de l’instruction en cours. Imaginez un scénario où vous démarrez une transaction contenant plusieurs instructions le 10/01/08 à 23h59, et où l’instruction contenant CURRENT\$1DATE s’exécute le 10/02/08 à 00h00. CURRENT\$1DATE renvoie `10/01/08`, et non `10/02/08`.
## Syntaxe
```
CURRENT_DATE
```
## Type de retour
DATE
## Exemple
L'exemple suivant renvoie la date actuelle (dans Région AWS laquelle la fonction s'exécute).
```
select current_date;
date
------------
2008-10-01
```
# Fonction CURRENT\$1TIMESTAMP
CURRENT\$1TIMESTAMP renvoie la date et l'heure actuelles, y compris la date, l'heure et (éventuellement) les millisecondes ou microsecondes.
Cette fonction est utile lorsque vous devez obtenir la date et l'heure actuelles, par exemple pour enregistrer l'horodatage d'un événement, pour effectuer des calculs basés sur le temps ou pour remplir des colonnes. date/time
## Syntaxe
```
current_timestamp()
```
## Type de retour
La fonction CURRENT\$1TIMESTAMP renvoie une DATE.
## Exemple
L'exemple suivant renvoie la date et l'heure actuelles au moment où la requête est exécutée, soit le 25 avril 2020 à 15:49:11.914 (15:49:11.914 PM).
```
SELECT current_timestamp();
2020-04-25 15:49:11.914
```
L'exemple suivant extrait la date et l'heure actuelles pour chaque ligne du `squirrels` tableau.
```
SELECT current_timestamp() FROM squirrels
```
# Fonction DATE\$1ADD
Renvoie la date qui est postérieure de num\$1jours à la date de début.
## Syntaxe
```
date_add(start_date, num_days)
```
## Arguments
*date\$1de début*
La valeur de la date de début.
*num\$1days*
Le nombre de jours à ajouter (entier). Un nombre positif ajoute des jours, un nombre négatif soustrait des jours.
## Type de retour
DATE
## Exemples
L'exemple suivant ajoute un jour à une date :
```
SELECT date_add('2016-07-30', 1);
Result:
2016-07-31
```
L'exemple suivant ajoute plusieurs jours.
```
SELECT date_add('2016-07-30', 5);
Result:
2016-08-04
```
## Notes d’utilisation
Cette documentation concerne la fonction DATE\$1ADD de Spark SQL, qui fournit une interface plus simple pour ajouter des jours aux dates par rapport à d'autres variantes SQL. Pour ajouter d'autres intervalles tels que des mois ou des années, différentes fonctions peuvent être nécessaires.
# Fonction DATE\$1DIFF
DATE\$1DIFF renvoie la différence entre les parties datées de deux expressions de date ou d'heure.
## Syntaxe
```
date_diff(endDate, startDate)
```
## Arguments
*endDate*
Expression DATE.
*startDate*
Expression DATE.
## Type de retour
BIGINT
## Exemples avec une colonne DATE
L’exemple suivant met en évidence la différence, en nombre de semaines, entre deux valeurs de date littérales.
```
select date_diff(week,'2009-01-01','2009-12-31') as numweeks;
numweeks
----------
52
(1 row)
```
L’exemple suivant permet de trouver la différence, en heures, entre deux valeurs littérales de date. Si vous n’indiquez pas la valeur temporelle d’une date, celle-ci est fixée par défaut à 00:00:00.
```
select date_diff(hour, '2023-01-01', '2023-01-03 05:04:03');
date_diff
----------
53
(1 row)
```
L’exemple suivant permet de trouver la différence, en jours, entre deux valeurs TIMESTAMETZ littérales.
```
Select date_diff(days, 'Jun 1,2008 09:59:59 EST', 'Jul 4,2008 09:59:59 EST')
date_diff
----------
33
```
L’exemple suivant permet de trouver la différence, en jours, entre deux dates figurant sur la même ligne d’une table.
```
select * from date_table;
start_date | end_date
-----------+-----------
2009-01-01 | 2009-03-23
2023-01-04 | 2024-05-04
(2 rows)
select date_diff(day, start_date, end_date) as duration from date_table;
duration
---------
81
486
(2 rows)
```
L’exemple suivant met en évidence la différence, dans le nombre de trimestres, entre une valeur littérale dans le passé et la date du jour. Cet exemple suppose que la date du jour est le 5 juin 2008. Vous pouvez nommer les parties de date intégralement ou les abréger. Le nom de colonne par défaut de la fonction DATE\$1DIFF est DATE\$1DIFF.
```
select date_diff(qtr, '1998-07-01', current_date);
date_diff
-----------
40
(1 row)
```
L’exemple suivant joint les tables SALES et LISTING pour calculer combien de jours après leur mise en vente des billets ont été vendus pour les listes 1000 à 1005. L’attente la plus longue pour les ventes de ces listes a été 15 jours, et la plus courte a été de moins d’une journée (0 jour).
```
select priceperticket,
date_diff(day, listtime, saletime) as wait
from sales, listing where sales.listid = listing.listid
and sales.listid between 1000 and 1005
order by wait desc, priceperticket desc;
priceperticket | wait
---------------+------
96.00 | 15
123.00 | 11
131.00 | 9
123.00 | 6
129.00 | 4
96.00 | 4
96.00 | 0
(7 rows)
```
Cet exemple calcule la moyenne du nombre d’heures que les vendeurs ont attendu pour toutes les ventes de billets.
```
select avg(date_diff(hours, listtime, saletime)) as avgwait
from sales, listing
where sales.listid = listing.listid;
avgwait
---------
465
(1 row)
```
## Exemples avec une colonne TIME
L'exemple de table TIME\$1TEST suivant comporte une colonne TIME\$1VAL (type TIME) avec trois valeurs insérées.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
L’exemple suivant montre comment trouver la différence en nombre d’heures entre la colonne TIME\$1VAL et une valeur de temps littérale.
```
select date_diff(hour, time_val, time '15:24:45') from time_test;
date_diff
-----------
-5
15
15
```
L’exemple suivant montre comment trouver la différence en nombre de minutes entre deux valeurs de temps littérales.
```
select date_diff(minute, time '20:00:00', time '21:00:00') as nummins;
nummins
----------
60
```
## Exemples avec une colonne TIMETZ
L'exemple de table TIMETZ\$1TEST suivant comporte une colonne TIMETZ\$1VAL (type TIMETZ) avec trois valeurs insérées.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
L’exemple suivant montre comment trouver la différence en nombre d’heures entre une valeur TIMETZ littérale et une valeur timez\$1val.
```
select date_diff(hours, timetz '20:00:00 PST', timetz_val) as numhours from timetz_test;
numhours
----------
0
-4
1
```
L’exemple suivant montre comment trouver la différence en nombre d’heures entre deux valeurs TIMETZ littérales.
```
select date_diff(hours, timetz '20:00:00 PST', timetz '00:58:00 EST') as numhours;
numhours
----------
1
```
# Fonction DATE\$1PART
DATE\$1PART extrait des valeurs date part d’une expression. DATE\$1PART est un synonyme de la fonction PGDATE\$1PART.
## Syntaxe
```
datepart(field, source)
```
## Arguments
*champ*
La partie de la source qui doit être extraite et les valeurs de chaîne prises en charge sont les mêmes que les champs de la fonction équivalente EXTRACT.
*source*
Colonne DATE ou INTERVAL à partir de laquelle le champ doit être extrait.
## Type de retour
Si *le champ* est « DEUXIÈME », une décimale (8, 6). Dans tous les autres cas, un INTEGER.
## Exemple
L'exemple suivant extrait le jour de l'année (DOY) à partir d'une valeur de date. La sortie indique que le jour de l'année pour la date « 2019-08-12 » est. `224` Cela signifie que le 12 août 2019 est le 224e jour de l'année 2019.
```
SELECT datepart('doy', DATE'2019-08-12');
224
```
# Fonction DATE\$1TRUNC
La fonction DATE\$1TRUNC tronque une expression d’horodatage ou littérale en fonction de la partie de date que vous spécifiez, telle que l’heure, le jour ou le mois.
## Syntaxe
```
date_trunc(format, datetime)
```
## Arguments
*format*
Format représentant l'unité à tronquer. Les formats valides sont les suivants :
+ « ANNÉE », « YYYY », « YY » - tronqués à la première date de l'année où le ts tombe, la partie temporelle sera nulle
+ « TRIMESTRE » : tronquez à la première date du trimestre où le ts tombe, la partie temporelle sera nulle
+ « MONTH », « MM », « MON » - tronquez à la première date du mois où le ts tombe, la partie temporelle sera nulle
+ « SEMAINE » : tronquez au lundi de la semaine où le ts tombe, le temps sera nul
+ « JOUR », « DD » - mettez à zéro la partie horaire
+ « HEURE » : zéro la minute et la seconde avec une fraction
+ « MINUTE » : zéro la seconde avec une fraction
+ « DEUXIÈME » - met à zéro la deuxième fraction
+ « MILLISECOND » - mettez à zéro les microsecondes
+ « MICROSECONDE » - tout reste
*ts*
Une valeur date/heure
## Type de retour
Renvoie l'horodatage *ts* tronqué à l'unité spécifiée par le modèle de format
## Exemples
L'exemple suivant tronque une valeur de date au début de l'année. Le résultat indique que la date « 2015-03-05" a été tronquée en « 2015-01-01", ce qui correspond au début de l'année 2015.
```
SELECT date_trunc('YEAR', '2015-03-05');
date_trunc
-----------
2015-01-01
```
# Fonction DAY
La fonction DAY renvoie le jour du mois correspondant à la date/à l'horodatage.
Les fonctions d'extraction de date sont utiles lorsque vous devez travailler avec des composants spécifiques d'une date ou d'un horodatage, par exemple lorsque vous effectuez des calculs basés sur la date, que vous filtrez des données ou que vous formatez des valeurs de date.
## Syntaxe
```
day(date)
```
## Arguments
*date*
Expression DATE ou TIMESTAMP.
## Renvoie
La fonction DAY renvoie un INTEGER.
## Exemples
L'exemple suivant extrait le jour du mois (`30`) de la date saisie`'2009-07-30'`.
```
SELECT day('2009-07-30');
30
```
L'exemple suivant extrait le jour du mois de la `birthday` colonne du `squirrels` tableau et renvoie les résultats sous forme de sortie de l'instruction SELECT. Le résultat de cette requête sera une liste de valeurs de jour, une pour chaque ligne du `squirrels` tableau, représentant le jour du mois pour l'anniversaire de chaque écureuil.
```
SELECT day(birthday) FROM squirrels
```
# Fonction DAYOFMONTH
La fonction DAYOFMONTH renvoie le jour du mois du date/timestamp (une valeur comprise entre 1 et 31, selon le mois et l'année).
La fonction DAYOFMONTH est similaire à la fonction DAY, mais leur nom et leur comportement sont légèrement différents. La fonction DAY est plus couramment utilisée, mais la fonction DAYOFMONTH peut être utilisée comme alternative. Ce type de requête peut être utile lorsque vous devez effectuer une analyse basée sur la date ou un filtrage sur une table contenant des données de date ou d'horodatage, par exemple pour extraire des composants spécifiques d'une date à des fins de traitement ou de génération de rapports ultérieurs.
## Syntaxe
```
dayofmonth(date)
```
## Arguments
*date*
Expression DATE ou TIMESTAMP.
## Renvoie
La fonction DAYOFMONTH renvoie un INTEGER.
## Exemple
L'exemple suivant extrait le jour du mois (`30`) de la date saisie`'2009-07-30'`.
```
SELECT dayofmonth('2009-07-30');
30
```
L'exemple suivant applique la fonction DAYOFMONTH à la `birthday` colonne du `squirrels` tableau. Pour chaque ligne du `squirrels` tableau, le jour du mois indiqué dans la `birthday` colonne sera extrait et renvoyé en sortie de l'instruction SELECT. Le résultat de cette requête sera une liste de valeurs de jour, une pour chaque ligne du `squirrels` tableau, représentant le jour du mois pour l'anniversaire de chaque écureuil.
```
SELECT dayofmonth(birthday) FROM squirrels
```
# Fonction DAYOFWEEK
La fonction DAYOFWEEK saisit une date ou un horodatage et renvoie le jour de la semaine sous forme de chiffre (1 pour le dimanche, 2 pour le lundi,..., 7 pour le samedi).
Cette fonction d'extraction de date est utile lorsque vous devez travailler avec des composants spécifiques d'une date ou d'un horodatage, par exemple lorsque vous effectuez des calculs basés sur la date, que vous filtrez des données ou que vous formatez des valeurs de date.
## Syntaxe
```
dayofweek(date)
```
## Arguments
*date*
Expression DATE ou TIMESTAMP.
## Renvoie
La fonction DAYOFWEEK renvoie un INTEGER où
1 = dimanche
2 = lundi
3 = mardi
4 = mercredi
5 = jeudi
6 = Vendredi
7 = samedi
## Exemples
L'exemple suivant extrait le jour de la semaine à partir de cette date, qui est 5 (représentant le jeudi).
```
SELECT dayofweek('2009-07-30');
5
```
L'exemple suivant extrait le jour de la semaine de la `birthday` colonne du `squirrels` tableau et renvoie les résultats sous forme de sortie de l'instruction SELECT. Le résultat de cette requête sera une liste de valeurs du jour de la semaine, une pour chaque ligne du `squirrels` tableau, représentant le jour de la semaine pour l'anniversaire de chaque écureuil.
```
SELECT dayofweek(birthday) FROM squirrels
```
# Fonction DAYOFYEAR
La fonction DAYOFYEAR est une fonction d'extraction de date qui prend une date ou un horodatage comme entrée et renvoie le jour de l'année (une valeur comprise entre 1 et 366, selon l'année et selon qu'il s'agit d'une année bissextile).
Cette fonction est utile lorsque vous devez travailler avec des composants spécifiques d'une date ou d'un horodatage, par exemple lorsque vous effectuez des calculs basés sur la date, lorsque vous filtrez des données ou que vous formatez des valeurs de date.
## Syntaxe
```
dayofyear(date)
```
## Arguments
*date*
Expression DATE ou TIMESTAMP.
## Renvoie
La fonction DAYOFYEAR renvoie un INTEGER (compris entre 1 et 366, selon l'année et selon qu'il s'agit d'une année bissextile).
## Exemples
L'exemple suivant extrait le jour de l'année (`100`) de la date d'entrée`'2016-04-09'`.
```
SELECT dayofyear('2016-04-09');
100
```
L'exemple suivant extrait le jour de l'année de la `birthday` colonne du `squirrels` tableau et renvoie les résultats sous forme de sortie de l'instruction SELECT.
```
SELECT dayofyear(birthday) FROM squirrels
```
# Fonction EXTRACT
La fonction EXTRACT renvoie une partie de date ou d’heure à partir d’une valeur TIMESTAMP, TIMESTAMPTZ, TIME ou TIMETZ. Les exemples incluent le jour, le mois, l’année, l’heure, la minute, la seconde, la milliseconde ou la microseconde d’un horodatage.
## Syntaxe
```
EXTRACT(datepart FROM source)
```
## Arguments
*datepart*
Sous-champ d’une date ou d’une heure à extraire, tel que le jour, le mois, l’année, l’heure, la minute, la seconde, la milliseconde ou la microseconde. Pour les valeurs possibles, consultez [Parties de date pour les fonctions de date ou d'horodatage](Dateparts_for_datetime_functions.md).
*source*
Une colonne ou une expression qui évalue un type de données TIMESTAMP, TIMESTAMPTZ, TIME ou TIMETZ.
## Type de retour
INTEGER si la valeur *source* est de type TIMESTAMP, TIME ou TIMETZ.
DOUBLE PRECISION si la valeur *source* est de type TIMESTAMPTZ.
## Exemples avec TIME
L’exemple de table TIME\$1TEST suivant comporte une colonne TIME\$1VAL (type TIME) avec trois valeurs insérées.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
L’exemple suivant extrait les minutes de chaque time\$1val.
```
select extract(minute from time_val) as minutes from time_test;
minutes
-----------
0
0
58
```
L’exemple suivant extrait les heures de chaque time\$1val.
```
select extract(hour from time_val) as hours from time_test;
hours
-----------
20
0
0
```
# Fonction FROM\$1UTC\$1TIMESTAMP
La fonction FROM\$1UTC\$1TIMESTAMP convertit la date d'entrée de l'UTC (temps universel coordonné) vers le fuseau horaire spécifié.
Cette fonction est utile lorsque vous devez convertir des valeurs de date et d'heure de l'UTC vers un fuseau horaire spécifique. Cela peut être important lorsque vous travaillez avec des données provenant de différentes régions du monde et qui doivent être présentées à l'heure locale appropriée.
## Syntaxe
```
from_utc_timestamp(timestamp, timezone
```
## Arguments
*timestamp*
Une expression TIMESTAMP avec un horodatage UTC.
*timezone*
Expression STRING correspondant à un fuseau horaire valide dans lequel la date ou l'horodatage en entrée doivent être convertis.
## Renvoie
La fonction FROM\$1UTC\$1TIMESTAMP renvoie un TIMESTAMP.
## Exemple
L'exemple suivant convertit la date d'entrée de l'heure UTC vers le fuseau horaire spécifié (`'Asia/Seoul'`), qui dans ce cas est 9 heures avant l'heure UTC. Le résultat obtenu est la date et l'heure dans le fuseau horaire de Séoul, qui est`2016-08-31 09:00:00`.
```
SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');
2016-08-31 09:00:00
```
# Fonction HOUR
La fonction HOUR est une fonction d'extraction de l'heure qui prend une heure ou un horodatage en entrée et renvoie le composant horaire (une valeur comprise entre 0 et 23).
Cette fonction d'extraction temporelle est utile lorsque vous devez travailler avec des composants spécifiques d'une heure ou d'un horodatage, par exemple lorsque vous effectuez des calculs temporels, que vous filtrez des données ou que vous formatez des valeurs temporelles.
## Syntaxe
```
hour(timestamp)
```
## Arguments
*timestamp*
Expression TIMESTAMP.
## Renvoie
La fonction HOUR renvoie un INTEGER.
## Exemple
L'exemple suivant extrait le composant horaire (`12`) de l'horodatage `'2009-07-30 12:58:59'` d'entrée.
```
SELECT hour('2009-07-30 12:58:59');
12
```
# Fonction MINUTE
La fonction MINUTE est une fonction d'extraction de l'heure qui prend une heure ou un horodatage comme entrée et renvoie le composant minute (une valeur comprise entre 0 et 60).
## Syntaxe
```
minute(timestamp)
```
## Arguments
*timestamp*
Une expression TIMESTAMP ou une CHAÎNE d'un format d'horodatage valide.
## Renvoie
La fonction MINUTE renvoie un INTEGER.
## Exemple
L'exemple suivant extrait le composant minute (`58`) de l'horodatage `'2009-07-30 12:58:59'` d'entrée.
```
SELECT minute('2009-07-30 12:58:59');
58
```
# Fonction MONTH
La fonction MONTH est une fonction d'extraction de l'heure qui prend une heure ou un horodatage comme entrée et renvoie le composant du mois (une valeur comprise entre 0 et 12).
## Syntaxe
```
month(date)
```
## Arguments
*date*
Une expression TIMESTAMP ou une CHAÎNE d'un format d'horodatage valide.
## Renvoie
La fonction MONTH renvoie un INTEGER.
## Exemple
L'exemple suivant extrait le composant du mois (`7`) de l'horodatage `'2016-07-30'` d'entrée.
```
SELECT month('2016-07-30');
7
```
# DEUXIÈME fonction
La fonction SECOND est une fonction d'extraction temporelle qui prend une heure ou un horodatage en entrée et renvoie le second composant (une valeur comprise entre 0 et 60).
## Syntaxe
```
second(timestamp)
```
## Arguments
*timestamp*
Expression TIMESTAMP.
## Renvoie
La fonction SECOND renvoie un INTEGER.
## Exemple
L'exemple suivant extrait le deuxième composant (`59`) de l'horodatage `'2009-07-30 12:58:59'` d'entrée.
```
SELECT second('2009-07-30 12:58:59');
59
```
# Fonction TIMESTAMP
La fonction TIMESTAMP prend une valeur (généralement un nombre) et la convertit en un type de données d'horodatage.
Cette fonction est utile lorsque vous devez convertir une valeur numérique représentant une heure ou une date en un type de données d'horodatage. Cela peut être utile lorsque vous travaillez avec des données stockées dans un format numérique, comme les horodatages Unix ou l'heure d'époque.
## Syntaxe
```
timestamp(expr)
```
## Arguments
*expr*
Toute expression pouvant être convertie en TIMESTAMP.
## Renvoie
La fonction TIMESTAMP renvoie un TIMESTAMP.
## Exemple
L'exemple suivant convertit un timestamp numérique Unix (`1632416400`) en son type de données d'horodatage correspondant : 22 septembre 2021 à 12 h 00 UTC.
```
SELECT timestamp(1632416400);
2021-09-22 12:00:00 UTC
```
# Fonction TO\$1TIMESTAMP
TO\$1TIMESTAMP convertit une chaîne TIMESTAMP en TIMESTAMPTZ.
## Syntaxe
```
to_timestamp (timestamp)
```
```
to_timestamp (timestamp, format)
```
## Arguments
*timestamp*
Chaîne d'horodatage ou type de données pouvant être converti en chaîne d'horodatage.
*format*
Chaîne littérale qui correspond aux modèles de date/heure de Spark. Pour les modèles de date/heure valides, voir Modèles de [date/heure pour le formatage et](https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html) l'analyse syntaxique.
## Type de retour
TIMESTAMP
## Exemples
L'exemple suivant montre comment utiliser la fonction TO\$1TIMESTAMP pour convertir une chaîne TIMESTAMP en TIMESTAMP.
```
select current_timestamp() as timestamp, to_timestamp( current_timestamp(), 'YYYY-MM-DD HH24:MI:SS') as second;
timestamp | second
-------------------------- ----------------------
2021-04-05 19:27:53.281812 | 2021-04-05 19:27:53+00
```
Il est possible de transmettre la partie TO\$1TIMESTAMP d’une date. Les autres parties de la date sont définies sur des valeurs par défaut. L’heure est incluse dans la sortie :
```
SELECT TO_TIMESTAMP('2017','YYYY');
to_timestamp
--------------------------
2017-01-01 00:00:00+00
```
L'instruction SQL suivante convertit la chaîne « 2011-12-18 24:38:15 » en TIMESTAMP. Le résultat est un horodatage qui tombe le jour suivant car le nombre d'heures est supérieur à 24 heures :
```
select to_timestamp('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS');
to_timestamp
----------------------
2011-12-19 00:38:15+00
```
# Fonction YEAR
La fonction YEAR est une fonction d'extraction de date qui prend une date ou un horodatage en entrée et renvoie le composant annuel (un nombre à quatre chiffres).
## Syntaxe
```
year(date)
```
## Arguments
*date*
Expression DATE ou TIMESTAMP.
## Renvoie
La fonction YEAR renvoie un INTEGER.
## Exemple
L'exemple suivant extrait le composant annuel (`2016`) de la date d'entrée`'2016-07-30'`.
```
SELECT year('2016-07-30');
2016
```
L'exemple suivant extrait le composant annuel de la `birthday` colonne du `squirrels` tableau et renvoie les résultats sous forme de sortie de l'instruction SELECT. Le résultat de cette requête sera une liste de valeurs annuelles, une pour chaque ligne du `squirrels` tableau, représentant l'année de naissance de chaque écureuil.
```
SELECT year(birthday) FROM squirrels
```
# Parties de date pour les fonctions de date ou d'horodatage
Le tableau suivant identifie les noms de partie de date et d’horodatage et les abréviations qui sont acceptées comme arguments pour les fonctions suivantes :
+ DATE\$1ADD
+ DATE\$1DIFF
+ DATE\$1PART
+ EXTRACT
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/clean-rooms/latest/sql-reference/Dateparts_for_datetime_functions.html)
## Variations de résultats avec les secondes, les millisecondes et les microsecondes
Des différences mineures dans les résultats de la requête se produisent lorsque d’autres fonctions de date spécifient les secondes, les millisecondes ou les microsecondes comme des parties de date :
+ La fonction EXTRACT renvoie des nombres entiers pour la partie de date spécifiée uniquement, sans tenir compte des parties de date de niveau supérieur et inférieur. Si la partie de date spécifiée est les secondes, les millisecondes et les microsecondes ne figurent pas dans le résultat. Si la partie de date spécifiée est les millisecondes, les secondes et les microsecondes ne sont pas incluses. Si la partie de date spécifiée est les microsecondes, les secondes et les millisecondes ne sont pas incluses.
+ La fonction DATE\$1PART renvoie la seconde partie complète de l’horodatage, quelle que soit la partie de date spécifiée, en renvoyant une valeur décimale ou un nombre entier comme requis.
## Remarques sur CENTURY, EPOCH, DECADE et MIL
CENTURY ou CENTURIES
AWS Clean Rooms interprète un CENTURY comme commençant par l'année *\$1\$1 \$11* et se terminant par l'année : `###0`
```
select extract (century from timestamp '2000-12-16 12:21:13');
date_part
-----------
20
(1 row)
select extract (century from timestamp '2001-12-16 12:21:13');
date_part
-----------
21
(1 row)
```
EPOCH
L' AWS Clean Rooms implémentation d'EPOCH est relative au 1970-01-01 00:00:00.000 quel que soit le fuseau horaire dans lequel réside le cluster. Vous devrez peut-être décaler les résultats de la différence en heures selon le fuseau horaire sur lequel se trouve le cluster.
DECADE ou DECADES
AWS Clean Rooms interprète le DECADE ou DECADES DATEPART en fonction du calendrier commun. Par exemple, si le calendrier commun commence à partir de l’année 1, la première décennie (décennie 1) est 0001-01-01 jusqu’au 0009-12-31, et la deuxième décennie (décennie 2) du 0010-01-01 au 0019-12-31. Par exemple, la décennie 201 s’étend du 2000-01-01 au 2009-12-31 :
```
select extract(decade from timestamp '1999-02-16 20:38:40');
date_part
-----------
200
(1 row)
select extract(decade from timestamp '2000-02-16 20:38:40');
date_part
-----------
201
(1 row)
select extract(decade from timestamp '2010-02-16 20:38:40');
date_part
-----------
202
(1 row)
```
MIL ou MILS
AWS Clean Rooms interprète un MIL comme commençant par le premier jour de l'année *\$1001* et se terminant par le dernier jour de l'année `#000` :
```
select extract (mil from timestamp '2000-12-16 12:21:13');
date_part
-----------
2
(1 row)
select extract (mil from timestamp '2001-12-16 12:21:13');
date_part
-----------
3
(1 row)
```
# Fonctions de chiffrement et de déchiffrement
Les fonctions de chiffrement et de déchiffrement aident les développeurs SQL à protéger les données sensibles contre tout accès non autorisé ou toute utilisation abusive en les convertissant entre une forme lisible en texte clair et une forme chiffrée illisible.
AWS Clean Rooms Spark SQL prend en charge les fonctions de chiffrement et de déchiffrement suivantes :
**Topics**
+ [Fonction AES\$1ENCRYPT](AES_ENCRYPT.md)
+ [Fonction AES\$1DECRYPT](AES_DECRYPT.md)
# Fonction AES\$1ENCRYPT
La fonction AES\$1ENCRYPT est utilisée pour chiffrer les données à l'aide de l'algorithme AES (Advanced Encryption Standard).
## Syntaxe
```
aes_encrypt(expr, key[, mode[, padding[, iv[, aad]]]])
```
## Arguments
*expr*
La valeur binaire à chiffrer.
*key*
Phrase secrète à utiliser pour chiffrer les données.
Les longueurs de clé de 16, 24 et 32 bits sont prises en charge.
*mode*
Spécifie le mode de chiffrement par blocs à utiliser pour chiffrer les messages.
Modes valides : ECB (électronique CodeBook), GCM (mode Galois/Counter), CBC (Cipher-Block Chaining).
*rembourrage*
Spécifie comment ajouter des messages dont la longueur n'est pas un multiple de la taille du bloc.
Valeurs valides : PKCS, NONE, DEFAULT.
Le remplissage DEFAULT signifie PKCS (Public Key Cryptography Standards) pour ECB, NONE pour GCM et PKCS pour CBC.
Les combinaisons prises en charge de (*mode*, *rembourrage*) sont (« ECB », « PKCS »), (« GCM », « NONE ») et (« CBC », « PKCS »).
*iv*
Vecteur d'initialisation facultatif (IV). Compatible uniquement avec les modes CBC et GCM.
Valeurs valides : 12 octets pour le GCM et 16 octets pour le CBC.
*aad*
Données authentifiées supplémentaires (AAD) facultatives. Compatible uniquement avec le mode GCM. Il peut s'agir de n'importe quelle entrée libre et doit être fournie à la fois pour le chiffrement et le déchiffrement.
## Type de retour
La fonction AES\$1ENCRYPT renvoie une valeur cryptée de *expr* en utilisant AES dans un mode donné avec le rembourrage spécifié.
## Exemples
L'exemple suivant montre comment utiliser la fonction Spark SQL AES\$1ENCRYPT pour chiffrer de manière sécurisée une chaîne de données (dans ce cas, le mot « Spark ») à l'aide d'une clé de chiffrement spécifiée. Le texte chiffré obtenu est ensuite codé en Base64 pour faciliter son stockage ou sa transmission.
```
SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop'));
4A5jOAh9FNGwoMeuJukfllrLdHEZxA2DyuSQAWz77dfn
```
L'exemple suivant montre comment utiliser la fonction Spark SQL AES\$1ENCRYPT pour chiffrer de manière sécurisée une chaîne de données (dans ce cas, le mot « Spark ») à l'aide d'une clé de chiffrement spécifiée. Le texte chiffré obtenu est ensuite représenté au format hexadécimal, ce qui peut être utile pour des tâches telles que le stockage, la transmission ou le débogage de données.
```
SELECT hex(aes_encrypt('Spark', '0000111122223333'));
83F16B2AA704794132802D248E6BFD4E380078182D1544813898AC97E709B28A94
```
L'exemple suivant montre comment utiliser la fonction Spark SQL AES\$1ENCRYPT pour chiffrer de manière sécurisée une chaîne de données (dans ce cas, « Spark SQL ») à l'aide d'une clé de chiffrement, d'un mode de chiffrement et d'un mode de remplissage spécifiés. Le texte chiffré obtenu est ensuite codé en Base64 pour faciliter son stockage ou sa transmission.
```
SELECT base64(aes_encrypt('Spark SQL', '1234567890abcdef', 'ECB', 'PKCS'));
3lmwu+Mw0H3fi5NDvcu9lg==
```
# Fonction AES\$1DECRYPT
La fonction AES\$1DECRYPT est utilisée pour déchiffrer les données à l'aide de l'algorithme AES (Advanced Encryption Standard).
## Syntaxe
```
aes_decrypt(expr, key[, mode[, padding[, aad]]])
```
## Arguments
*expr*
La valeur binaire à déchiffrer.
*key*
Phrase secrète à utiliser pour déchiffrer les données.
La phrase secrète doit correspondre à la clé utilisée à l'origine pour produire la valeur cryptée et avoir une longueur de 16, 24 ou 32 octets.
*mode*
Spécifie le mode de chiffrement par blocs à utiliser pour déchiffrer les messages.
Modes valides : ECB, GCM, CBC.
*rembourrage*
Spécifie comment ajouter des messages dont la longueur n'est pas un multiple de la taille du bloc.
Valeurs valides : PKCS, NONE, DEFAULT.
Le rembourrage DEFAULT signifie PKCS pour ECB, NONE pour GCM et PKCS pour CBC.
*aad*
Données authentifiées supplémentaires (AAD) facultatives. Compatible uniquement avec le mode GCM. Il peut s'agir de n'importe quelle entrée libre et doit être fournie à la fois pour le chiffrement et le déchiffrement.
## Type de retour
Renvoie une valeur déchiffrée de *expr en utilisant AES en mode* avec rembourrage.
## Exemples
L'exemple suivant montre comment utiliser la fonction Spark SQL AES\$1ENCRYPT pour chiffrer de manière sécurisée une chaîne de données (dans ce cas, le mot « Spark ») à l'aide d'une clé de chiffrement spécifiée. Le texte chiffré obtenu est ensuite codé en Base64 pour faciliter son stockage ou sa transmission.
```
SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop'));
4A5jOAh9FNGwoMeuJukfllrLdHEZxA2DyuSQAWz77dfn
```
L'exemple suivant montre comment utiliser la fonction Spark SQL AES\$1DECRYPT pour déchiffrer des données précédemment chiffrées et codées en Base64. Le processus de déchiffrement nécessite la clé de chiffrement et les paramètres appropriés (mode de chiffrement et mode de remplissage) pour récupérer correctement les données en texte brut d'origine.
```
SELECT aes_decrypt(unbase64('3lmwu+Mw0H3fi5NDvcu9lg=='), '1234567890abcdef', 'ECB', 'PKCS');
Spark SQL
```
# Fonctions de hachage
Une fonction de hachage est une fonction mathématique qui convertit une valeur d’entrée numérique en une autre valeur.
AWS Clean Rooms Spark SQL prend en charge les fonctions de hachage suivantes :
**Topics**
+ [MD5 fonction](s_MD5.md)
+ [Fonction SHA](s_SHA.md)
+ [SHA1 fonction](s_SHA1.md)
+ [SHA2 fonction](s_SHA2.md)
+ [HASH64 fonction xx](xxhash64.md)
# MD5 fonction
Utilise la fonction de hachage MD5 cryptographique pour convertir une chaîne de longueur variable en une chaîne de 32 caractères qui est une représentation textuelle de la valeur hexadécimale d'une somme de contrôle de 128 bits.
## Syntaxe
```
MD5(string)
```
## Arguments
*string*
Chaîne de longueur variable.
## Type de retour
La MD5 fonction renvoie une chaîne de 32 caractères qui est une représentation textuelle de la valeur hexadécimale d'une somme de contrôle de 128 bits.
## Exemples
L'exemple suivant illustre la valeur de 128 bits de la chaîne « AWS Clean Rooms » :
```
select md5('AWS Clean Rooms');
md5
----------------------------------
f7415e33f972c03abd4f3fed36748f7a
(1 row)
```
# Fonction SHA
Synonyme de SHA1 fonction.
Consultez [SHA1 fonction](s_SHA1.md).
# SHA1 fonction
La SHA1 fonction utilise la fonction de hachage SHA1 cryptographique pour convertir une chaîne de longueur variable en une chaîne de 40 caractères qui est une représentation textuelle de la valeur hexadécimale d'une somme de contrôle de 160 bits.
## Syntaxe
SHA1 est un synonyme de. [Fonction SHA](s_SHA.md)
```
SHA1(string)
```
## Arguments
*string*
Chaîne de longueur variable.
## Type de retour
La SHA1 fonction renvoie une chaîne de 40 caractères qui est une représentation textuelle de la valeur hexadécimale d'une somme de contrôle de 160 bits.
## exemple
L'exemple suivant renvoie la valeur de 160 bits du mot « AWS Clean Rooms » :
```
select sha1('AWS Clean Rooms');
```
# SHA2 fonction
La SHA2 fonction utilise la fonction de hachage SHA2 cryptographique pour convertir une chaîne de longueur variable en chaîne de caractères. La chaîne de caractères est une représentation textuelle de la valeur hexadécimale du total de contrôle avec le nombre de bits spécifié.
## Syntaxe
```
SHA2(string, bits)
```
## Arguments
*string*
Chaîne de longueur variable.
*integer*
Nombre de bits dans les fonctions de hachage. Les valeurs valides sont 0 (identique à 256), 224, 256, 384 et 512.
## Type de retour
La SHA2 fonction renvoie une chaîne de caractères qui est une représentation textuelle de la valeur hexadécimale de la somme de contrôle ou une chaîne vide si le nombre de bits n'est pas valide.
## exemple
L'exemple suivant renvoie la valeur de 256 bits du mot « AWS Clean Rooms » :
```
select sha2('AWS Clean Rooms', 256);
```
# HASH64 fonction xx
La fonction xxhash64 renvoie une valeur de hachage des arguments sur 64 bits.
La fonction xxhash64 () est une fonction de hachage non cryptographique conçue pour être rapide et efficace. Il est souvent utilisé dans les applications de traitement et de stockage de données, où un identifiant unique est nécessaire pour une donnée, mais le contenu exact des données n'a pas besoin d'être gardé secret.
Dans le contexte d'une requête SQL, la fonction xxhash64 () peut être utilisée à diverses fins, par exemple :
+ Génération d'un identifiant unique pour une ligne d'un tableau
+ Partitionnement des données en fonction d'une valeur de hachage
+ Mise en œuvre de stratégies d'indexation ou de distribution de données personnalisées
Le cas d'utilisation spécifique dépendra des exigences de l'application et des données traitées.
## Syntaxe
```
xxhash64(expr1, expr2, ...)
```
## Arguments
*expr1*
Expression de n'importe quel type.
*expr2*
Expression de n'importe quel type.
## Renvoie
Renvoie une valeur de hachage des arguments sur 64 bits (BIGINT). La graine de haschisch est de 42.
## exemple
L'exemple suivant génère une valeur de hachage de 64 bits (5602566077635097486) en fonction de l'entrée fournie. Le premier argument est une valeur de chaîne, dans ce cas, le mot « Spark ». Le deuxième argument est un tableau contenant la seule valeur entière 123. Le troisième argument est une valeur entière représentant le point de départ de la fonction de hachage.
```
SELECT xxhash64('Spark', array(123), 2);
5602566077635097486
```
# Fonctions Hyperloglog
Les fonctions HyperLogLog (HLL) de SQL permettent d'estimer efficacement le nombre d'éléments uniques (cardinalité) dans un ensemble de données volumineux, même lorsque l'ensemble réel d'éléments uniques n'est pas stocké.
Les principaux avantages de l'utilisation des fonctions HLL sont les suivants :
+ **Efficacité de la mémoire** : les esquisses HLL nécessitent beaucoup moins de mémoire que le stockage de l'ensemble complet d'éléments uniques, ce qui les rend adaptées à de grands ensembles de données.
+ **Informatique distribuée** : les esquisses HLL peuvent être combinées entre plusieurs sources de données ou nœuds de traitement, ce qui permet une estimation distribuée efficace du nombre unique.
+ **Résultats approximatifs** : HLL fournit une estimation du nombre unique approximative, avec un compromis ajustable entre précision et utilisation de la mémoire (via le paramètre de précision).
Ces fonctions sont particulièrement utiles dans les scénarios où vous devez estimer le nombre d'éléments uniques, tels que dans les applications d'analyse, d'entreposage de données et de traitement de flux en temps réel.
AWS Clean Rooms prend en charge les fonctions HLL suivantes.
**Topics**
+ [Fonction HLL\$1SKETCH\$1AGG](HLL_SKETCH_AGG.md)
+ [Fonction HLL\$1SKETCH\$1ESTIMATE](HLL_SKETCH_ESTIMATE.md)
+ [Fonction HLL\$1UNION](HLL_UNION.md)
+ [Fonction HLL\$1UNION\$1AGG](HLL_UNION_AGG.md)
# Fonction HLL\$1SKETCH\$1AGG
La fonction d'agrégation HLL\$1SKETCH\$1AGG crée une esquisse HLL à partir des valeurs de la colonne spécifiée. Elle renvoie un type de données HLLSKETCH qui encapsule les valeurs des expressions d'entrée.
La fonction d'agrégation HLL\$1SKETCH\$1AGG fonctionne avec tous les types de données et ignore les valeurs NULL.
Lorsqu’il n’y a pas de lignes dans une table ou que toutes les lignes sont NULL, le schéma résultant n’a pas de paires index-valeur telles que `{"version":1,"logm":15,"sparse":{"indices":[],"values":[]}}`.
## Syntaxe
```
HLL_SKETCH_AGG (aggregate_expression[, lgConfigK ] )
```
## Argument
*aggregate\$1expression*
Toute expression de type INT, BIGINT, STRING ou BINARY par rapport à laquelle un comptage unique sera effectué. Toutes `NULL` les valeurs sont ignorées.
*LG Configk*
Une constante INT optionnelle comprise entre 4 et 21 inclus avec 12 par défaut. Log-base-2 de K, où K est le nombre de compartiments ou de fentes pour l'esquisse.
## Type de retour
La fonction HLL\$1SKETCH\$1AGG renvoie un tampon BINAIRE non NULL contenant l' HyperLogLog esquisse calculée en raison de la consommation et de l'agrégation de toutes les valeurs d'entrée du groupe d'agrégation.
## Exemples
Les exemples suivants utilisent l'algorithme HyperLogLog (HLL) pour estimer le nombre distinct de valeurs dans la `col` colonne. La `hll_sketch_agg(col, 12)` fonction agrège les valeurs de la colonne col pour créer une esquisse HLL avec une précision de 12. La `hll_sketch_estimate()` fonction est ensuite utilisée pour estimer le nombre distinct de valeurs sur la base de l'esquisse HLL générée. Le résultat final de la requête est 3, ce qui représente le nombre distinct estimé de valeurs dans la `col` colonne. Dans ce cas, les valeurs distinctes sont 1, 2 et 3.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
L'exemple suivant utilise également l'algorithme HLL pour estimer le nombre distinct de valeurs dans la `col` colonne, mais il ne spécifie pas de valeur de précision pour l'esquisse HLL. Dans ce cas, il utilise la précision par défaut de 14. La `hll_sketch_agg(col)` fonction prend les valeurs de la `col` colonne et crée une esquisse HyperLogLog (HLL), qui est une structure de données compacte qui peut être utilisée pour estimer le nombre distinct d'éléments. La `hll_sketch_estimate(hll_sketch_agg(col))` fonction prend l'esquisse HLL créée à l'étape précédente et calcule une estimation du nombre distinct de valeurs dans la `col` colonne. Le résultat final de la requête est 3, ce qui représente le nombre distinct estimé de valeurs dans la `col` colonne. Dans ce cas, les valeurs distinctes sont 1, 2 et 3.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
# Fonction HLL\$1SKETCH\$1ESTIMATE
La fonction HLL\$1SKETCH\$1ESTIMATE prend une esquisse HLL et estime le nombre d'éléments uniques représentés par l'esquisse. Il utilise l'algorithme HyperLogLog (HLL) pour compter une approximation probabiliste du nombre de valeurs uniques dans une colonne donnée, en consommant une représentation binaire connue sous le nom de tampon d'esquisse précédemment générée par la fonction HLL\$1SKETCH\$1AGG et en renvoyant le résultat sous la forme d'un grand entier.
L'algorithme d'esquisse HLL fournit un moyen efficace d'estimer le nombre d'éléments uniques, même pour de grands ensembles de données, sans avoir à stocker l'ensemble complet des valeurs uniques.
Les `hll_union_agg` fonctions `hll_union` et peuvent également combiner des esquisses en consommant et en fusionnant ces tampons en tant qu'entrées.
## Syntaxe
```
HLL_SKETCH_ESTIMATE (hllsketch_expression)
```
## Argument
*hllsketch\$1expression*
`BINARY`Expression contenant une esquisse générée par HLL\$1SKETCH\$1AGG
## Type de retour
La fonction HLL\$1SKETCH\$1ESTIMATE renvoie une valeur BIGINT correspondant au nombre distinct approximatif représenté par l'esquisse en entrée.
## Exemples
Les exemples suivants utilisent l'algorithme d'esquisse HyperLogLog (HLL) pour estimer la cardinalité (nombre unique) des valeurs de la colonne. `col` La `hll_sketch_agg(col, 12)` fonction prend la `col` colonne et crée une esquisse HLL avec une précision de 12 bits. L'esquisse HLL est une structure de données approximative qui permet d'estimer efficacement le nombre d'éléments uniques dans un ensemble. La `hll_sketch_estimate()` fonction prend l'esquisse HLL créée par `hll_sketch_agg` et estime la cardinalité (nombre unique) des valeurs représentées par l'esquisse. `FROM VALUES (1), (1), (2), (2), (3) tab(col);`Génère un ensemble de données de test de 5 lignes, où la `col` colonne contient les valeurs 1, 1, 2, 2 et 3. Le résultat de cette requête est le nombre unique estimé des valeurs de la `col` colonne, qui est de 3.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
La différence entre l'exemple suivant et le précédent est que le paramètre de précision (12 bits) n'est pas spécifié dans l'appel de `hll_sketch_agg` fonction. Dans ce cas, la précision par défaut de 14 bits est utilisée, ce qui peut fournir une estimation plus précise du nombre unique par rapport à l'exemple précédent qui utilisait 12 bits de précision.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
# Fonction HLL\$1UNION
La fonction HLL\$1UNION combine deux esquisses HLL en une seule esquisse unifiée. Il utilise l'algorithme HyperLogLog (HLL) pour combiner deux esquisses en une seule. Les requêtes peuvent utiliser les tampons obtenus pour calculer des nombres uniques approximatifs sous forme de longs entiers avec la `hll_sketch_estimate` fonction.
## Syntaxe
```
HLL_UNION (( expr1, expr2 [, allowDifferentLgConfigK ] ))
```
## Argument
*ExPRN*
`BINARY`Expression contenant une esquisse générée par HLL\$1SKETCH\$1AGG.
*allowDifferentLgConfiguration K*
Expression BOOLEAN facultative contrôlant s'il faut autoriser la fusion de deux esquisses avec des valeurs LGConfigk différentes. La valeur par défaut est `false`.
## Type de retour
La fonction HLL\$1UNION renvoie une mémoire tampon BINAIRE contenant l' HyperLogLog esquisse calculée à la suite de la combinaison des expressions d'entrée. Lorsque le `allowDifferentLgConfigK` paramètre est défini`true`, l'esquisse du résultat utilise la plus petite des deux `lgConfigK` valeurs fournies.
## Exemples
Les exemples suivants utilisent l'algorithme d'esquisse HyperLogLog (HLL) pour estimer le nombre unique de valeurs sur deux colonnes `col1` et `col2` dans un ensemble de données.
La `hll_sketch_agg(col1)` fonction crée une esquisse HLL pour les valeurs uniques de la `col1` colonne.
La `hll_sketch_agg(col2)` fonction crée une esquisse HLL pour les valeurs uniques de la colonne col2.
La `hll_union(...)` fonction combine les deux esquisses HLL créées aux étapes 1 et 2 en une seule esquisse HLL unifiée.
La `hll_sketch_estimate(...)` fonction prend l'esquisse HLL combinée et estime le nombre unique de valeurs entre les deux `col1` et`col2`.
La `FROM VALUES` clause génère un ensemble de données de test de 5 lignes, `col1` contenant les valeurs 1, 1, 2, 2 et 3, et `col2` contenant les valeurs 4, 4, 5, 5 et 6.
Le résultat de cette requête est le nombre unique estimé de valeurs entre les deux `col1` et`col2`, qui est de 6. L'algorithme d'esquisse HLL fournit un moyen efficace d'estimer le nombre d'éléments uniques, même pour de grands ensembles de données, sans avoir à stocker l'ensemble complet des valeurs uniques. Dans cet exemple, la `hll_union` fonction est utilisée pour combiner les esquisses HLL des deux colonnes, ce qui permet d'estimer le nombre unique pour l'ensemble de données, plutôt que pour chaque colonne individuellement.
```
SELECT hll_sketch_estimate(
hll_union(
hll_sketch_agg(col1),
hll_sketch_agg(col2)))
FROM VALUES
(1, 4),
(1, 4),
(2, 5),
(2, 5),
(3, 6) AS tab(col1, col2);
6
```
La différence entre l'exemple suivant et le précédent est que le paramètre de précision (12 bits) n'est pas spécifié dans l'appel de `hll_sketch_agg` fonction. Dans ce cas, la précision par défaut de 14 bits est utilisée, ce qui peut fournir une estimation plus précise du nombre unique par rapport à l'exemple précédent qui utilisait 12 bits de précision.
```
SELECT hll_sketch_estimate(
hll_union(
hll_sketch_agg(col1, 14),
hll_sketch_agg(col2, 14)))
FROM VALUES
(1, 4),
(1, 4),
(2, 5),
(2, 5),
(3, 6) AS tab(col1, col2);
```
# Fonction HLL\$1UNION\$1AGG
La fonction HLL\$1UNION\$1AGG combine plusieurs esquisses HLL en une seule esquisse unifiée. Il utilise l'algorithme HyperLogLog (HLL) pour combiner un groupe de croquis en un seul. Les requêtes peuvent utiliser les tampons obtenus pour calculer des nombres uniques approximatifs à l'aide de la `hll_sketch_estimate` fonction.
## Syntaxe
```
HLL_UNION_AGG ( expr [, allowDifferentLgConfigK ] )
```
## Argument
*expr*
`BINARY`Expression contenant une esquisse générée par HLL\$1SKETCH\$1AGG.
*allowDifferentLgConfiguration K*
Expression BOOLEAN facultative contrôlant s'il faut autoriser la fusion de deux esquisses avec des valeurs LGConfigk différentes. La valeur par défaut est `false`.
## Type de retour
La fonction HLL\$1UNION\$1AGG renvoie une mémoire tampon BINAIRE contenant l' HyperLogLog esquisse calculée en combinant les expressions d'entrée du même groupe. Lorsque le `allowDifferentLgConfigK` paramètre est défini`true`, l'esquisse du résultat utilise la plus petite des deux `lgConfigK` valeurs fournies.
## Exemples
Les exemples suivants utilisent l'algorithme d'esquisse HyperLogLog (HLL) pour estimer le nombre unique de valeurs dans plusieurs esquisses HLL.
Le premier exemple estime le nombre unique de valeurs dans un ensemble de données.
```
SELECT hll_sketch_estimate(hll_union_agg(sketch, true))
FROM (SELECT hll_sketch_agg(col) as sketch
FROM VALUES (1) AS tab(col)
UNION ALL
SELECT hll_sketch_agg(col, 20) as sketch
FROM VALUES (1) AS tab(col));
1
```
La requête interne crée deux esquisses HLL :
+ La première instruction SELECT crée une esquisse à partir d'une valeur unique de 1.
+ La deuxième instruction SELECT crée une esquisse à partir d'une autre valeur unique de 1, mais avec une précision de 20.
La requête externe utilise la fonction HLL\$1UNION\$1AGG pour combiner les deux esquisses en une seule esquisse. Il applique ensuite la fonction HLL\$1SKETCH\$1ESTIMATE à cette esquisse combinée pour estimer le nombre unique de valeurs.
Le résultat de cette requête est le nombre unique estimé des valeurs de la `col` colonne, qui est`1`. Cela signifie que les deux valeurs d'entrée de 1 sont considérées comme uniques, même si elles ont la même valeur.
Le deuxième exemple inclut un paramètre de précision différent pour la fonction HLL\$1UNION\$1AGG. Dans ce cas, les deux esquisses HLL sont créées avec une précision de 14 bits, ce qui permet de les combiner avec succès à l'aide `hll_union_agg` du `true` paramètre.
```
SELECT hll_sketch_estimate(hll_union_agg(sketch, true))
FROM (SELECT hll_sketch_agg(col, 14) as sketch
FROM VALUES (1) AS tab(col)
UNION ALL
SELECT hll_sketch_agg(col, 14) as sketch
FROM VALUES (1) AS tab(col));
1
```
Le résultat final de la requête est le nombre unique estimé, qui dans ce cas l'est également`1`. Cela signifie que les deux valeurs d'entrée de 1 sont considérées comme uniques, même si elles ont la même valeur.
# Fonctions JSON
Lorsque vous avez besoin de stocker un ensemble relativement petit de paires clé-valeur, vous pouvez économiser de l’espace en stockant les données au format JSON. Étant donné que les chaînes au format JSON peuvent être stockées dans une seule colonne, l’utilisation de JSON peut être plus efficace que de stocker vos données sous forme de table.
**Example**
Supposons, par exemple, que vous disposiez d'un tableau clairsemé, dans lequel vous devez disposer de nombreuses colonnes pour représenter pleinement tous les attributs possibles. Cependant, la plupart des valeurs de colonne sont NULL pour une ligne ou une colonne donnée. En utilisant le JSON pour le stockage, vous pouvez peut-être stocker les données d'une ligne sous forme de paires clé-valeur dans une seule chaîne JSON et éliminer les colonnes de table peu remplies.
En outre, vous pouvez facilement modifier les chaînes au format JSON pour stocker des paires clé:valeur supplémentaires sans avoir besoin d’ajouter des colonnes à une table.
Nous vous conseillons d’utiliser JSON avec modération. Le JSON n'est pas un bon choix pour stocker des ensembles de données plus volumineux car, en stockant des données disparates dans une seule colonne, le JSON n'utilise pas l'architecture du magasin de AWS Clean Rooms colonnes.
JSON utilise des chaînes de texte codées UTF-8, les chaînes JSON peuvent donc être stockées sous forme de types de données CHAR ou VARCHAR. Utilisez VARCHAR si les chaînes incluent des caractères de plusieurs octets.
Les chaînes JSON doivent être au bon format JSON, selon les règles suivantes :
+ Le JSON de niveau racine peut être un objet JSON ou un tableau JSON. Un objet JSON est un ensemble non trié de paires clé:valeur séparées par des virgules délimitées par des accolades.
Par exemple, `{"one":1, "two":2} `
+ Un tableau JSON est un ensemble ordonné de valeurs séparées par des virgules délimitées par des crochets.
Voici un exemple : `["first", {"one":1}, "second", 3, null] `.
+ Les tableaux JSON utilisent un index de base zéro ; le premier élément d’un tableau se trouve à la position 0. Dans une paire clé:valeur JSON, la clé est une chaîne entre guillemets doubles.
+ Une valeur JSON peut être l’une des suivantes :
+ Objet JSON
+ un tableau JSON
+ Chaîne entre guillemets
+ Nombre (entier et à virgule flottante)
+ Booléen
+ Null
+ Les objets vides et les tableaux vides sont des valeurs JSON valides.
+ Les champs JSON sont sensibles à la casse.
+ Les espace vides entre les éléments structurels JSON (tel que `{ }, [ ]`) sont ignorés.
**Topics**
+ [Fonction GET\$1JSON\$1OBJECT](GET_JSON_OBJECT.md)
+ [Fonction TO\$1JSON](TO_JSON.md)
# Fonction GET\$1JSON\$1OBJECT
La fonction GET\$1JSON\$1OBJECT extrait un objet json à partir de. `path`
## Syntaxe
```
get_json_object(json_txt, path)
```
## Arguments
*json\$1txt*
Expression STRING contenant du JSON bien formé.
*chemin*
Un littéral STRING avec une expression de chemin JSON bien formée.
## Renvoie
Renvoie une chaîne.
Une valeur NULL est renvoyée si l'objet est introuvable.
## exemple
L'exemple suivant extrait une valeur d'un objet JSON. Le premier argument est une chaîne JSON qui représente un objet simple avec une seule paire clé-valeur. Le deuxième argument est une expression de chemin JSON. Le `$` symbole représente la racine de l'objet JSON, et la `.a` partie indique que nous voulons extraire la valeur associée à la clé `a` « ». La sortie de la fonction est « `b` », qui est la valeur associée à la touche « `a` » dans l'objet JSON d'entrée.
```
SELECT get_json_object('{"a":"b"}', '$.a');
b
```
# Fonction TO\$1JSON
La fonction TO\$1JSON convertit une expression d'entrée en une représentation sous forme de chaîne JSON. La fonction gère la conversion de différents types de données (tels que des nombres, des chaînes et des booléens) en leurs représentations JSON correspondantes.
La fonction TO\$1JSON est utile lorsque vous devez convertir des données structurées (telles que des lignes de base de données ou des objets JSON) dans un format plus portable et autodescriptif tel que JSON. Cela peut être particulièrement utile lorsque vous devez interagir avec d'autres systèmes ou services qui attendent des données au format JSON.
## Syntaxe
```
to_json(expr[, options])
```
## Arguments
*expr*
Expression d'entrée que vous souhaitez convertir en chaîne JSON. Il peut s'agir d'une valeur, d'une colonne ou de toute autre expression SQL valide.
*options*
Ensemble facultatif d'options de configuration qui peuvent être utilisées pour personnaliser le processus de conversion JSON. Ces options peuvent inclure des éléments tels que la gestion des valeurs nulles, la représentation de valeurs numériques et le traitement des caractères spéciaux.
## Renvoie
Renvoie une chaîne JSON avec une valeur de structure donnée
## Exemples
L'exemple suivant convertit une structure nommée (un type de données structurées) en chaîne JSON. Le premier argument`(named_struct('a', 1, 'b', 2)`) est l'expression d'entrée transmise à la `to_json()` fonction. Il crée une structure nommée avec deux champs : « a » avec une valeur de 1, et « b » avec une valeur de 2. La fonction to\$1json () prend la structure nommée comme argument et la convertit en une représentation sous forme de chaîne JSON. La sortie est`{"a":1,"b":2}`, qui est une chaîne JSON valide qui représente la structure nommée.
```
SELECT to_json(named_struct('a', 1, 'b', 2));
{"a":1,"b":2}
```
L'exemple suivant convertit une structure nommée contenant une valeur d'horodatage en une chaîne JSON, avec un format d'horodatage personnalisé. Le premier argument (`named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd'))`) crée une structure nommée avec un seul champ « time » contenant la valeur d'horodatage. Le deuxième argument (`map('timestampFormat', 'dd/MM/yyyy')`) crée une carte (dictionnaire clé-valeur) avec une seule paire clé-valeur, où la clé est « TimestampFormat » et la valeur est « ». dd/MM/yyyy'. This map is used to specify the desired format for the timestamp value when converting it to JSON. The to\$1json() function converts the named struct into a JSON string. The second argument, the map, is used to customize the timestamp format to 'dd/MM/yyyy La sortie est `{"time":"26/08/2015"}` une chaîne JSON avec un seul champ « heure » contenant la valeur d'horodatage au format « dd/MM/yyyy » souhaité.
```
SELECT to_json(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
{"time":"26/08/2015"}
```
# Fonctions mathématiques
Cette section décrit les opérateurs mathématiques et les fonctions pris en charge dans AWS Clean Rooms Spark SQL.
**Topics**
+ [Symboles d’opérateurs mathématiques](OPERATOR_SYMBOLS.md)
+ [Fonction ABS](ABS.md)
+ [Fonction ACOS](ACOS.md)
+ [Fonction ASIN](ASIN.md)
+ [Fonction ATAN](ATAN.md)
+ [ATAN2 fonction](ATAN2.md)
+ [Fonction CBRT](CBRT.md)
+ [Fonction CEILING (ou CEIL)](CEILING_FLOOR.md)
+ [Fonction COS](COS.md)
+ [Fonction COT](COT.md)
+ [Fonction DEGREES](DEGREES.md)
+ [Fonction DIV](DIV.md)
+ [Fonction EXP](EXP.md)
+ [Fonction FLOOR](FLOOR.md)
+ [Fonction LN](LN.md)
+ [Fonction LOG](LOG.md)
+ [Fonction MOD](MOD.md)
+ [Fonction PI](PI.md)
+ [Fonction POWER](POWER.md)
+ [Fonction RADIANS](RADIANS.md)
+ [Fonction RAND](RAND.md)
+ [Fonction RANDOM](RANDOM.md)
+ [Fonction ROUND](ROUND.md)
+ [Fonction SIGN](SIGN.md)
+ [Fonction SIN](SIN.md)
+ [Fonction SQRT](SQRT.md)
+ [Fonction TRUNC](TRUNC.md)
# Symboles d’opérateurs mathématiques
Le tableau suivant répertorie les opérateurs mathématiques pris en charge.
## Opérateurs pris en charge
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/clean-rooms/latest/sql-reference/OPERATOR_SYMBOLS.html)
## Exemples
Calculez la commission payée plus des frais de gestion de 2\$1 pour une transaction donnée :
```
select commission, (commission + 2.00) as comm
from sales where salesid=10000;
commission | comm
-----------+-------
28.05 | 30.05
(1 row)
```
Calculer 20 % du prix de vente pour une transaction donnée :
```
select pricepaid, (pricepaid * .20) as twentypct
from sales where salesid=10000;
pricepaid | twentypct
----------+-----------
187.00 | 37.400
(1 row)
```
Prévoyez le nombre de billets vendus en fonction d'un modèle de croissance continue. Dans cet exemple, la sous-requête renvoie le nombre de billets vendus en 2008. Ce résultat est multiplié de façon exponentielle par un taux de croissance continu de 5 % sur 10 ans.
```
select (select sum(qtysold) from sales, date
where sales.dateid=date.dateid and year=2008)
^ ((5::float/100)*10) as qty10years;
qty10years
------------------
587.664019657491
(1 row)
```
Trouvez le prix total payé et les commissions pour les ventes dont le numéro de date est supérieur ou égal à 2 000. Puis soustrayez la commission totale du prix total payé.
```
select sum (pricepaid) as sum_price, dateid,
sum (commission) as sum_comm, (sum (pricepaid) - sum (commission)) as value
from sales where dateid >= 2000
group by dateid order by dateid limit 10;
sum_price | dateid | sum_comm | value
-----------+--------+----------+-----------
364445.00 | 2044 | 54666.75 | 309778.25
349344.00 | 2112 | 52401.60 | 296942.40
343756.00 | 2124 | 51563.40 | 292192.60
378595.00 | 2116 | 56789.25 | 321805.75
328725.00 | 2080 | 49308.75 | 279416.25
349554.00 | 2028 | 52433.10 | 297120.90
249207.00 | 2164 | 37381.05 | 211825.95
285202.00 | 2064 | 42780.30 | 242421.70
320945.00 | 2012 | 48141.75 | 272803.25
321096.00 | 2016 | 48164.40 | 272931.60
(10 rows)
```
# Fonction ABS
ABS calcule la valeur absolue d’un nombre, où ce nombre peut être littéral ou une expression qui a pour valeur un nombre.
## Syntaxe
```
ABS (number)
```
## Arguments
*number*
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir de SMALLINT, INTEGER, BIGINT, DECIMAL ou de type. FLOAT4 FLOAT8
## Type de retour
ABS renvoie le même type de données que sont argument.
## Exemples
Calculez la valeur absolue de -38 :
```
select abs (-38);
abs
-------
38
(1 row)
```
Calculez la valeur absolue de (14-76) :
```
select abs (14-76);
abs
-------
62
(1 row)
```
# Fonction ACOS
ACOS est une fonction trigonométrique qui renvoie l’arc cosinus d’un nombre. La valeur de retour est exprimée en radians et se situe entre `0` et `PI`.
## Syntaxe
```
ACOS(number)
```
## Arguments
*number*
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`.
## Type de retour
`DOUBLE PRECISION`
## Exemples
Pour renvoyer l’arc cosinus de `-1`, utilisez l’exemple suivant.
```
SELECT ACOS(-1);
+-------------------+
| acos |
+-------------------+
| 3.141592653589793 |
+-------------------+
```
# Fonction ASIN
ASIN est une fonction trigonométrique qui renvoie l’arc sinus d’un nombre. La valeur de retour est exprimée en radians et se situe entre `PI/2` et `-PI/2`.
## Syntaxe
```
ASIN(number)
```
## Arguments
*number*
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`.
## Type de retour
`DOUBLE PRECISION`
## Exemples
Pour renvoyer l’arc sinus de `1`, utilisez l’exemple suivant.
```
SELECT ASIN(1) AS halfpi;
+--------------------+
| halfpi |
+--------------------+
| 1.5707963267948966 |
+--------------------+
```
# Fonction ATAN
ATAN est une fonction trigonométrique qui renvoie l’arc tangente d’un nombre. La valeur de retour est exprimée en radians et se situe entre `-PI` et `PI`.
## Syntaxe
```
ATAN(number)
```
## Arguments
*number*
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`.
## Type de retour
`DOUBLE PRECISION`
## Exemples
Pour renvoyer l’arc tangente de `1` et le multiplier par 4, utilisez l’exemple suivant.
```
SELECT ATAN(1) * 4 AS pi;
+-------------------+
| pi |
+-------------------+
| 3.141592653589793 |
+-------------------+
```
# ATAN2 fonction
ATAN2 est une fonction trigonométrique qui renvoie l'arc tangente d'un nombre divisé par un autre nombre. La valeur de retour est exprimée en radians et se situe entre `PI/2` et `-PI/2`.
## Syntaxe
```
ATAN2(number1, number2)
```
## Arguments
*number1*
Nombre `DOUBLE PRECISION`.
*number2*
Nombre `DOUBLE PRECISION`.
## Type de retour
`DOUBLE PRECISION`
## Exemples
Pour renvoyer l’arc tangente de `2/2` et le multiplier par 4, utilisez l’exemple suivant.
```
SELECT ATAN2(2,2) * 4 AS PI;
+-------------------+
| pi |
+-------------------+
| 3.141592653589793 |
+-------------------+
```
# Fonction CBRT
La fonction CBRT est une fonction mathématique qui calcule la racine cubique d'un nombre.
## Syntaxe
```
CBRT (number)
```
## Argument
CBRT prend un certain nombre DOUBLE PRECISION en tant qu'argument.
## Type de retour
CBRT renvoie un nombre DOUBLE PRECISION.
## Exemples
Calculez la racine cubique de la commission payée pour une transaction donnée :
```
select cbrt(commission) from sales where salesid=10000;
cbrt
------------------
3.03839539048843
(1 row)
```
# Fonction CEILING (ou CEIL)
La fonction CEILING (ou CEIL) permet d’arrondir un nombre jusqu’au nombre entier supérieur suivant. (Le [Fonction FLOOR](FLOOR.md) arrondit un nombre au nombre entier inférieur suivant.)
## Syntaxe
```
CEIL | CEILING(number)
```
## Arguments
*number*
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir de SMALLINT, INTEGER, BIGINT, DECIMAL ou de type. FLOAT4 FLOAT8
## Type de retour
CEILING et CEIL renvoient le même type de données que leur argument.
## Exemple
Calculez le plafond de la commission payée pour une transaction de vente donnée :
```
select ceiling(commission) from sales
where salesid=10000;
ceiling
---------
29
(1 row)
```
# Fonction COS
COS est une fonction trigonométrique qui renvoie le cosinus d’un nombre. La valeur de retour est exprimée en radians et se situe entre `-1` et `1`, inclus.
## Syntaxe
```
COS(double_precision)
```
## Argument
*number*
Le paramètre d'entrée est un nombre double précision.
## Type de retour
La fonction COS renvoie un nombre double précision.
## Exemples
L'exemple suivant renvoie le cosinus de 0 :
```
select cos(0);
cos
-----
1
(1 row)
```
L'exemple suivant renvoie le cosinus de PI :
```
select cos(pi());
cos
-----
-1
(1 row)
```
# Fonction COT
COT est une fonction trigonométrique qui renvoie la cotangente d’un nombre. Le paramètre d’entrée doit être différent de zéro.
## Syntaxe
```
COT(number)
```
## Argument
*number*
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`.
## Type de retour
`DOUBLE PRECISION`
## Exemples
Pour renvoyer la cotangente de 1, utilisez l’exemple suivant.
```
SELECT COT(1);
+--------------------+
| cot |
+--------------------+
| 0.6420926159343306 |
+--------------------+
```
# Fonction DEGREES
Convertit un angle en radians en son équivalent en degrés.
## Syntaxe
```
DEGREES(number)
```
## Argument
*number*
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`.
## Type de retour
`DOUBLE PRECISION`
## Exemple
Pour renvoyer l’équivalent en degrés de 0,5 radian, utilisez l’exemple suivant.
```
SELECT DEGREES(.5);
+-------------------+
| degrees |
+-------------------+
| 28.64788975654116 |
+-------------------+
```
Pour convertir PI radians en degrés, utilisez l’exemple suivant.
```
SELECT DEGREES(pi());
+---------+
| degrees |
+---------+
| 180 |
+---------+
```
# Fonction DIV
L'opérateur DIV renvoie la partie intégrante de la division du dividende par diviseur.
## Syntaxe
```
dividend div divisor
```
## Arguments
*dividende*
Expression dont l'évaluation correspond à un chiffre ou à un intervalle.
*divisor*
Un intervalle correspondant de type if `dividend` est un intervalle, un intervalle numérique dans le cas contraire.
## Type de retour
`BIGINT`
## Exemples
L'exemple suivant sélectionne deux colonnes dans la table des écureuils : la `id` colonne, qui contient l'identifiant unique de chaque écureuil, et une `calculated` colonne`age div 2`, qui représente la division entière de la colonne d'âge par 2. Le `age div 2` calcul effectue une division entière sur la `age` colonne, arrondissant ainsi l'âge au nombre entier pair le plus proche. Par exemple, si la `age` colonne contient des valeurs telles que 3, 5, 7 et 10, elle contiendra les valeurs 1, 2, 3 et 5, respectivement. `age div 2`
```
SELECT id, age div 2 FROM squirrels
```
Cette requête peut être utile dans les scénarios où vous devez regrouper ou analyser des données en fonction de tranches d'âge, et vous souhaitez simplifier les valeurs d'âge en les arrondissant à l'entier pair le plus proche. Le résultat obtenu fournirait l'âge `id` et l'âge divisés par 2 pour chaque écureuil du `squirrels` tableau.
# Fonction EXP
La fonction EXP implémente la fonction exponentielle pour une expression numérique, ou la base du logarithme naturel, `e`, élevée à la puissance de l'expression. La fonction EXP est l’inverse de [Fonction LN](LN.md).
## Syntaxe
```
EXP (expression)
```
## Argument
*expression*
L'expression doit être un type de données INTEGER, DECIMAL ou DOUBLE PRECISION.
## Type de retour
EXP renvoie un nombre DOUBLE PRECISION.
## Exemple
Utilisez la fonction EXP de planifier des ventes de billets selon un modèle de croissance continue. Dans cet exemple, la sous-requête renvoie le nombre de billets vendus en 2008. Ce résultat est multiplié par le résultat de la fonction EXP, qui spécifie une croissance continue de 7 % sur 10 ans.
```
select (select sum(qtysold) from sales, date
where sales.dateid=date.dateid
and year=2008) * exp((7::float/100)*10) qty2018;
qty2018
------------------
695447.483772222
(1 row)
```
# Fonction FLOOR
La fonction FLOOR arrondit un nombre au nombre entier inférieur suivant.
## Syntaxe
```
FLOOR (number)
```
## Argument
*number*
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir de SMALLINT, INTEGER, BIGINT, DECIMAL ou de type. FLOAT4 FLOAT8
## Type de retour
FLOOR renvoie le même type de données que sont argument.
## Exemple
L'exemple montre la valeur de la commission payée pour une transaction de vente donnée avant et après l'utilisation de la fonction FLOOR.
```
select commission from sales
where salesid=10000;
floor
-------
28.05
(1 row)
select floor(commission) from sales
where salesid=10000;
floor
-------
28
(1 row)
```
# Fonction LN
La fonction LN renvoie le logarithme naturel du paramètre d'entrée.
## Syntaxe
```
LN(expression)
```
## Argument
*expression*
Colonne cible ou expression sur laquelle la fonction opère.
Cette fonction renvoie une erreur pour certains types de données si l'expression fait référence à une table AWS Clean Rooms créée par l'utilisateur ou à une table AWS Clean Rooms système STL ou STV.
Les expressions régulières avec les types de données suivants génèrent une erreur si elles font référence à une table créée par l’utilisateur ou à une table système.
+ BOOLEAN
+ CHAR
+ DATE
+ DECIMAL ou NUMERIC
+ TIMESTAMP
+ VARCHAR
Les expressions régulières avec les types de données suivants s’exécutent avec succès sur des tables créées par l’utilisateur ou des tables système STL ou STV :
+ BIGINT
+ DOUBLE PRECISION
+ INTEGER
+ REAL
+ SMALLINT
## Type de retour
La fonction LN renvoie le même type que l'expression.
## Exemple
L'exemple suivant renvoie le logarithme naturel, ou logarithme de base e, du nombre 2,718281828 :
```
select ln(2.718281828);
ln
--------------------
0.9999999998311267
(1 row)
```
Notez que la réponse est presque égale à 1.
Cet exemple renvoie le logarithme naturel des valeurs de la colonne USERID de la table USERS :
```
select username, ln(userid) from users order by userid limit 10;
username | ln
----------+-------------------
JSG99FHE | 0
PGL08LJI | 0.693147180559945
IFT66TXU | 1.09861228866811
XDZ38RDD | 1.38629436111989
AEB55QTM | 1.6094379124341
NDQ15VBM | 1.79175946922805
OWY35QYB | 1.94591014905531
AZG78YIP | 2.07944154167984
MSD36KVR | 2.19722457733622
WKW41AIW | 2.30258509299405
(10 rows)
```
# Fonction LOG
Renvoie le logarithme de `expr` with`base`.
## Syntaxe
```
LOG(base, expr)
```
## Argument
*expr*
L’expression doit comporter un type de données de nombre entier, décimale ou à virgule flottante.
*base*
Base pour le calcul du logarithme. Doit être un nombre positif (différent de 1) de type de données à double précision.
## Type de retour
La fonction LOG renvoie un nombre double précision.
## Exemple
L'exemple suivant renvoie le logarithme de base 10 du chiffre 100 :
```
select log(10, 100);
--------
2
(1 row)
```
# Fonction MOD
Renvoie le reste de deux nombres, autrement dit une opération *modulo*. Pour calculer le résultat, le premier paramètre est divisé par le second.
## Syntaxe
```
MOD(number1, number2)
```
## Arguments
*number1*
Le premier paramètre d'entrée est un nombre INTEGER, SMALLINT, BIGINT ou DECIMAL. Si un paramètre est de type DECIMAL, l'autre paramètre doit également être un type DECIMAL. Si un paramètre est un INTEGER, l'autre paramètre peut être un INTEGER, SMALLINT ou BIGINT. Les deux paramètres peuvent également être SMALLINT ou BIGINT, mais un paramètre ne peut pas être un SMALLINT si l'autre est un BIGINT.
*number2*
Le second paramètre est un nombre INTEGER, SMALLINT, BIGINT ou DECIMAL. Les mêmes règles de type de données s’appliquent à *number2* en ce qui concerne *number1*.
## Type de retour
Les types de retour valides sont DECIMAL, INT, SMALLINT et BIGINT. Le type de retour de la fonction MOD est le même type numérique que les paramètres d’entrée, si les deux paramètres d’entrée sont de même type. Si un paramètre d'entrée est un INTEGER, toutefois, le type de retour sera également un INTEGER.
## Notes d’utilisation
Vous pouvez utiliser *%* comme opérateur modulo.
## Exemples
L'exemple suivant renvoie le reste lorsqu'un nombre est divisé par un autre :
```
SELECT MOD(10, 4);
mod
------
2
```
L'exemple suivant renvoie un résultat décimal :
```
SELECT MOD(10.5, 4);
mod
------
2.5
```
Vous pouvez projeter les valeurs des paramètres :
```
SELECT MOD(CAST(16.4 as integer), 5);
mod
------
1
```
Vérifiez si le premier paramètre est pair en le divisant par 2 :
```
SELECT mod(5,2) = 0 as is_even;
is_even
--------
false
```
Vous pouvez utiliser le *%* comme opérateur modulo :
```
SELECT 11 % 4 as remainder;
remainder
-----------
3
```
L'exemple suivant renvoie des informations pour les catégories impaires dans la table CATEGORY :
```
select catid, catname
from category
where mod(catid,2)=1
order by 1,2;
catid | catname
-------+-----------
1 | MLB
3 | NFL
5 | MLS
7 | Plays
9 | Pop
11 | Classical
(6 rows)
```
# Fonction PI
La fonction PI renvoie la valeur de pi à 14 décimales.
## Syntaxe
```
PI()
```
## Type de retour
`DOUBLE PRECISION`
## Exemples
Pour renvoyer la valeur de pi, utilisez l’exemple suivant.
```
SELECT PI();
+-------------------+
| pi |
+-------------------+
| 3.141592653589793 |
+-------------------+
```
# Fonction POWER
La fonction POWER est une fonction exponentielle qui élève une expression numérique à la puissance d’une seconde expression numérique. Par exemple, 2 à la puissance 3 est calculé sous la forme `POWER(2,3)`, avec un résultat de `8`.
## Syntaxe
```
{POWER(expression1, expression2)
```
## Arguments
*expression1*
Expression numérique à élever. Doit avoir le type de données `INTEGER`, `DECIMAL` ou `FLOAT`.
*expression2*
Puissance à laquelle élever *expression1*. Doit avoir le type de données `INTEGER`, `DECIMAL` ou `FLOAT`.
## Type de retour
`DOUBLE PRECISION`
## Exemple
```
SELECT (SELECT SUM(qtysold) FROM sales, date
WHERE sales.dateid=date.dateid
AND year=2008) * POW((1+7::FLOAT/100),10) qty2010;
+-------------------+
| qty2010 |
+-------------------+
| 679353.7540885945 |
+-------------------+
```
# Fonction RADIANS
La fonction RADIANS convertit un angle en degrés en son équivalent en radians.
## Syntaxe
```
RADIANS(number)
```
## Argument
*number*
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`.
## Type de retour
`DOUBLE PRECISION`
## Exemple
Pour renvoyer l’équivalent en radians de 180 degrés, utilisez l’exemple suivant.
```
SELECT RADIANS(180);
+-------------------+
| radians |
+-------------------+
| 3.141592653589793 |
+-------------------+
```
# Fonction RAND
La fonction RAND génère un nombre aléatoire à virgule flottante compris entre 0 et 1. La fonction RAND génère un nouveau nombre aléatoire à chaque fois qu'elle est appelée.
## Syntaxe
```
RAND()
```
## Type de retour
RANDOM renvoie un DOUBLE.
## Exemple
L'exemple suivant génère une colonne de nombres aléatoires à virgule flottante compris entre 0 et 1 pour chaque ligne du tableau. `squirrels` Le résultat obtenu serait une colonne unique contenant une liste de valeurs décimales aléatoires, avec une valeur pour chaque ligne de la table des écureuils.
```
SELECT rand() FROM squirrels
```
Ce type de requête est utile lorsque vous devez générer des nombres aléatoires, par exemple pour simuler des événements aléatoires ou pour introduire le caractère aléatoire dans votre analyse de données. Dans le contexte du `squirrels` tableau, il peut être utilisé pour attribuer des valeurs aléatoires à chaque écureuil, qui pourraient ensuite être utilisées pour un traitement ou une analyse plus poussés.
# Fonction RANDOM
La fonction RANDOM génère une valeur aléatoire compris entre 0,0 (inclus) et 1,0 (exclusif).
## Syntaxe
```
RANDOM()
```
## Type de retour
RANDOM renvoie un nombre DOUBLE PRECISION.
## Exemples
1. Calculez une valeur aléatoire comprise entre 0 et 99. Si le nombre aléatoire est de 0 à 1, cette requête génère un nombre aléatoire de 0 à 100 :
```
select cast (random() * 100 as int);
INTEGER
------
24
(1 row)
```
1. Récupère un échantillon aléatoire uniforme de 10 éléments :
```
select *
from sales
order by random()
limit 10;
```
Maintenant, récupérez un échantillon aléatoire de 10 éléments, mais choisissez les éléments en fonction de leur prix. Par exemple, un élément dont le prix est le double d'un autre a deux fois plus de chance d'apparaître dans les résultats de la requête :
```
select *
from sales
order by log(1 - random()) / pricepaid
limit 10;
```
1. Cet exemple utilise la commande SET pour définir une valeur SEED afin que RANDOM génère une séquence de nombres prévisible.
D’abord, renvoyez trois entiers RANDOM sans définir au préalable la valeur SEED :
```
select cast (random() * 100 as int);
INTEGER
------
6
(1 row)
select cast (random() * 100 as int);
INTEGER
------
68
(1 row)
select cast (random() * 100 as int);
INTEGER
------
56
(1 row)
```
A présent, définissez la valeur SEED sur `.25` et renvoyez trois nombres RANDOM supplémentaires :
```
set seed to .25;
select cast (random() * 100 as int);
INTEGER
------
21
(1 row)
select cast (random() * 100 as int);
INTEGER
------
79
(1 row)
select cast (random() * 100 as int);
INTEGER
------
12
(1 row)
```
Enfin, réinitialisez la valeur SEED sur `.25` et vérifiez que RANDOM renvoie les mêmes résultats que les trois appels précédents :
```
set seed to .25;
select cast (random() * 100 as int);
INTEGER
------
21
(1 row)
select cast (random() * 100 as int);
INTEGER
------
79
(1 row)
select cast (random() * 100 as int);
INTEGER
------
12
(1 row)
```
# Fonction ROUND
La fonction ROUND arrondit des nombres à l’entier ou à la décimale la plus proche.
La fonction ROUND peut éventuellement inclure un second argument sous forme de nombre entier permettant d'indiquer le nombre de décimales de l'arrondi, dans les deux sens. Lorsque vous ne fournissez pas le second argument, la fonction arrondit au nombre entier le plus proche. Lorsque le second argument *>n* est spécifié, la fonction arrondit au nombre le plus proche avec une précision de *n* décimales.
## Syntaxe
```
ROUND (number [ , integer ] )
```
## Argument
*number*
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir du DECIMAL ou du FLOAT8 type. AWS Clean Rooms peut convertir d'autres types de données selon les règles de conversion implicites.
*integer* (facultatif)
Nombre entier qui indique le nombre de décimales pour l'arrondi dans les deux sens.
## Type de retour
ROUND renvoie le même type de données numériques en tant qu'argument(s) d'entrée.
## Exemples
Arrondit la commission payée pour une transaction donnée au nombre entier le plus proche.
```
select commission, round(commission)
from sales where salesid=10000;
commission | round
-----------+-------
28.05 | 28
(1 row)
```
Arrondit la commission payée pour une transaction donnée à la première décimale.
```
select commission, round(commission, 1)
from sales where salesid=10000;
commission | round
-----------+-------
28.05 | 28.1
(1 row)
```
Pour la même requête, étendez la précision dans l'autre sens.
```
select commission, round(commission, -1)
from sales where salesid=10000;
commission | round
-----------+-------
28.05 | 30
(1 row)
```
# Fonction SIGN
La fonction SIGN renvoie le signe (positif ou négatif) d’un nombre. Le résultat de la fonction SIGN est `1`, `-1` ou `0`, ce qui indique le signe de l'argument.
## Syntaxe
```
SIGN (number)
```
## Argument
*number*
Nombre ou expression ayant pour valeur un nombre. C'est peut-être le DECIMALor FLOAT8 genre. AWS Clean Rooms peut convertir d'autres types de données selon les règles de conversion implicites.
## Type de retour
SIGN renvoie le même type de données numériques en tant qu'argument(s) d'entrée. Si l'entrée est DECIMAL, la sortie est DECIMAL(1,0).
## Exemples
Pour déterminer le signe de la commission payée pour une transaction donnée à partir de la table SALES, utilisez l’exemple suivant.
```
SELECT commission, SIGN(commission)
FROM sales WHERE salesid=10000;
+------------+------+
| commission | sign |
+------------+------+
| 28.05 | 1 |
+------------+------+
```
# Fonction SIN
SIN est une fonction trigonométrique qui renvoie le sinus d’un nombre. La valeur renvoyée est comprise entre `-1` et `1`.
## Syntaxe
```
SIN(number)
```
## Argument
*number*
Nombre `DOUBLE PRECISION` en radians.
## Type de retour
`DOUBLE PRECISION`
## Exemple
Pour renvoyer le sinus de `-PI`, utilisez l’exemple suivant.
```
SELECT SIN(-PI());
+-------------------------+
| sin |
+-------------------------+
| -0.00000000000000012246 |
+-------------------------+
```
# Fonction SQRT
La fonction SQRT renvoie la racine carrée d'une valeur numérique. La racine carrée est un nombre multiplié par lui-même pour obtenir la valeur donnée.
## Syntaxe
```
SQRT (expression)
```
## Argument
*expression*
L’expression doit comporter un type de données de nombre entier, décimale ou à virgule flottante. L'expression peut inclure des fonctions. Le système peut effectuer des conversions de type implicites.
## Type de retour
SQRT renvoie un nombre DOUBLE PRECISION.
## Exemples
L'exemple suivant renvoie la racine carrée d'un nombre.
```
select sqrt(16);
sqrt
---------------
4
```
L'exemple suivant effectue une conversion de type implicite.
```
select sqrt('16');
sqrt
---------------
4
```
L'exemple suivant imbrique des fonctions pour effectuer une tâche plus complexe.
```
select sqrt(round(16.4));
sqrt
---------------
4
```
L'exemple suivant donne la longueur du rayon lorsque l'aire du cercle est indiquée. Il calcule le rayon en pouces, par exemple, lorsque la surface est indiquée en pouces carrés. Dans l'exemple, l'aire est de 20.
```
select sqrt(20/pi());
```
La valeur renvoyée est 5.046265044040321.
L'exemple suivant renvoie la racine carrée des valeurs de COMMISSION de la table SALES. La colonne COMMISSION est une colonne DECIMAL. Cet exemple montre comment utiliser la fonction dans une requête ayant une logique conditionnelle plus complexe.
```
select sqrt(commission)
from sales where salesid < 10 order by salesid;
sqrt
------------------
10.4498803820905
3.37638860322683
7.24568837309472
5.1234753829798
...
```
La requête suivante renvoie la racine carré arrondie du même ensemble de valeurs COMMISSION.
```
select salesid, commission, round(sqrt(commission))
from sales where salesid < 10 order by salesid;
salesid | commission | round
--------+------------+-------
1 | 109.20 | 10
2 | 11.40 | 3
3 | 52.50 | 7
4 | 26.25 | 5
...
```
Pour plus d'informations sur les exemples de données dans AWS Clean Rooms, consultez la section [Exemple de base de données](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
# Fonction TRUNC
La fonction TRUNC tronque les nombres à l'entier ou à la décimale précédente.
La fonction TRUNC peut éventuellement inclure un second argument : un nombre entier permettant d'indiquer le nombre de décimales de l'arrondi, dans les deux sens. Lorsque vous ne fournissez pas le second argument, la fonction arrondit au nombre entier le plus proche. Lorsque le second argument *>n* est spécifié, la fonction arrondit au nombre le plus proche avec une précision de *n* décimales. Cette fonction tronque également un horodatage et renvoie une date.
## Syntaxe
```
TRUNC (number [ , integer ] |
timestamp )
```
## Arguments
*number*
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir du DECIMAL ou du FLOAT8 type. AWS Clean Rooms peut convertir d'autres types de données selon les règles de conversion implicites.
*integer* (facultatif)
Nombre entier qui indique le nombre de décimales de précision, dans les deux sens. Si aucun nombre entier n’est fourni, le nombre est tronqué en tant que nombre entier ; si un nombre entier est spécifié, le nombre est tronqué à la décimale spécifiée.
*timestamp*
La fonction peut également renvoyer la date à partir d'un horodatage. (Pour renvoyer une valeur d'horodatage avec `00:00:00` comme heure, envoyez le résultat de la fonction à un horodatage.)
## Type de retour
TRUNC renvoie le même type de données que le premier argument d'entrée. Pour les horodatages, TRUNC renvoie une date.
## Exemples
Tronque la commission payée pour une transaction de vente donnée.
```
select commission, trunc(commission)
from sales where salesid=784;
commission | trunc
-----------+-------
111.15 | 111
(1 row)
```
Tronque la même valeur de commission que la première décimale.
```
select commission, trunc(commission,1)
from sales where salesid=784;
commission | trunc
-----------+-------
111.15 | 111.1
(1 row)
```
Tronque la commission avec une valeur négative pour le second argument ; `111.15` est arrondi à `110`.
```
select commission, trunc(commission,-1)
from sales where salesid=784;
commission | trunc
-----------+-------
111.15 | 110
(1 row)
```
Renvoyez la partie de date du résultat de la fonction SYSDATE (qui renvoie un horodatage) :
```
select sysdate;
timestamp
----------------------------
2011-07-21 10:32:38.248109
(1 row)
select trunc(sysdate);
trunc
------------
2011-07-21
(1 row)
```
Appliquez la fonction TRUNC à une colonne TIMESTAMP. Le type de retour est une date.
```
select trunc(starttime) from event
order by eventid limit 1;
trunc
------------
2008-01-25
(1 row)
```
# Fonctions scalaires
Cette section décrit les fonctions scalaires prises en charge dans AWS Clean Rooms Spark SQL. Une fonction scalaire est une fonction qui prend une ou plusieurs valeurs en entrée et renvoie une seule valeur en sortie. Les fonctions scalaires fonctionnent sur des lignes ou des éléments individuels et produisent un résultat unique pour chaque entrée.
Les fonctions scalaires, telles que SIZE, sont différentes des autres types de fonctions SQL, telles que les fonctions d'agrégation (count, sum, avg) et les fonctions de génération de tables (explode, aplten). Ces autres types de fonctions fonctionnent sur plusieurs lignes ou génèrent plusieurs lignes, tandis que les fonctions scalaires fonctionnent sur des lignes ou des éléments individuels.
**Topics**
+ [fonction SIZE](size.md)
# fonction SIZE
La fonction SIZE prend un tableau, une carte ou une chaîne existant comme argument et renvoie une valeur unique représentant la taille ou la longueur de cette structure de données. Cela ne crée pas de nouvelle structure de données. Il est utilisé pour interroger et analyser les propriétés des structures de données existantes, plutôt que pour en créer de nouvelles.
Cette fonction est utile pour déterminer le nombre d'éléments d'un tableau ou la longueur d'une chaîne. Cela peut être particulièrement utile lorsque vous travaillez avec des tableaux et d'autres structures de données en SQL, car cela vous permet d'obtenir des informations sur la taille ou la cardinalité des données.
## Syntaxe
```
size(expr)
```
## Arguments
*expr*
Expression ARRAY, MAP ou STRING.
## Type de retour
La fonction SIZE renvoie un INTEGER.
## exemple
Dans cet exemple, la fonction SIZE est appliquée au tableau `['b', 'd', 'c', 'a']` et renvoie la valeur`4`, qui est le nombre d'éléments du tableau.
```
SELECT size(array('b', 'd', 'c', 'a'));
4
```
Dans cet exemple, la fonction SIZE est appliquée à la carte `{'a': 1, 'b': 2}` et renvoie la valeur`2`, qui est le nombre de paires clé-valeur sur la carte.
```
SELECT size(map('a', 1, 'b', 2));
2
```
Dans cet exemple, la fonction SIZE est appliquée à la chaîne `'hello world'` et renvoie la valeur`11`, qui est le nombre de caractères de la chaîne.
```
SELECT size('hello world');
11
```
# Fonctions de chaîne
Fonctions de chaîne qui traitent et manipulent des chaînes de caractères ou des expressions qui correspondent à des chaînes de caractères. Lorsque l’argument *string* de ces fonctions est une valeur littérale, il doit être entre guillemets simples. Les types de données pris en charge sont CHAR et VARCHAR.
La section suivante fournit les noms de fonctions, la syntaxe et les descriptions des fonctions prises en charge. Tous les décalages en chaînes sont basés sur un.
**Topics**
+ [Opérateur (concaténation) \$1\$1](concat_op.md)
+ [Fonction BTRIM](BTRIM.md)
+ [Fonction CONCAT](CONCAT.md)
+ [Fonction FORMAT\$1STRING](FORMAT_STRING.md)
+ [Fonctions LEFT et RIGHT](LEFT.md)
+ [Fonction LENGTH](LENGTH.md)
+ [Fonction LOWER](LOWER.md)
+ [Fonctions LPAD et RPAD](LPAD.md)
+ [Fonction LTRIM](LTRIM.md)
+ [Fonction POSITION](POSITION.md)
+ [Fonction REGEXP\$1COUNT](REGEXP_COUNT.md)
+ [Fonction REGEXP\$1INSTR](REGEXP_INSTR.md)
+ [Fonction REGEXP\$1REPLACE](REGEXP_REPLACE.md)
+ [Fonction REGEXP\$1SUBSTR](REGEXP_SUBSTR.md)
+ [Fonction REPEAT](REPEAT.md)
+ [Fonction REPLACE](REPLACE.md)
+ [Fonction REVERSE](REVERSE.md)
+ [Fonction RTRIM](RTRIM.md)
+ [Fonction SPLIT](split.md)
+ [Fonction SPLIT\$1PART](SPLIT_PART.md)
+ [Fonction SUBSTRING](SUBSTRING.md)
+ [Fonction TRANSLATE](TRANSLATE.md)
+ [Fonction TRIM](TRIM.md)
+ [Fonction UPPER](UPPER.md)
+ [Fonction UUID](UUID.md)
# Opérateur (concaténation) \$1\$1
Concatène deux expressions de chaque côté du symbole \$1\$1 et renvoie l’expression concaténée.
L'opérateur de concatentation est similaire à. [Fonction CONCAT](CONCAT.md)
**Note**
Pour la fonction CONCAT et l'opérateur de concaténation, si une expression ou les deux ont la valeur null, le résultat de la concaténation est null.
## Syntaxe
```
expression1 || expression2
```
## Arguments
*expression1*, *expression2*
Les deux arguments peuvent être des chaînes de caractères de longueur fixe ou de longueur variable ou des expressions.
## Type de retour
L'opérateur \$1\$1 renvoie une chaîne. Le type de chaîne est identique à celui des arguments d'entrée.
## exemple
L'exemple suivant concatène les champs FIRSTNAME et LASTNAME de la table USERS :
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
Pour concaténer des colonnes susceptibles de contenir des valeurs nulles, utilisez l’expression [Fonctions NVL et COALESCE](NVL_function.md). L’exemple suivant utilise NVL pour renvoyer un 0 chaque fois que la valeur NULL est rencontrée.
```
select venuename || ' seats ' || nvl(venueseats, 0)
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 10;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
Hilton Hotel seats 0
Luxor Hotel seats 0
Mandalay Bay Hotel seats 0
Mirage Hotel seats 0
New York New York seats 0
```
# Fonction BTRIM
La fonction BTRIM tronque une chaîne en supprimant les espaces de début et de fin ou en supprimant les caractères de début et de fin qui correspondent à une chaîne spécifiée de manière facultative.
## Syntaxe
```
BTRIM(string [, trim_chars ] )
```
## Arguments
*string*
Chaîne VARCHAR d’entrée à tronquer.
*trim\$1chars*
Chaîne VARCHAR contenant les caractères à mettre en correspondance.
## Type de retour
La fonction BTRIM renvoie une chaîne VARCHAR.
## Exemples
L’exemple suivant tronque les espaces de début et de fin de la chaîne `' abc '` :
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L’exemple suivant supprime les chaînes `'xyz'` de début et de fin de la chaîne `'xyzaxyzbxyzcxyz'`. Les occurrences de début et de fin de `'xyz'` sont supprimées, mais celles qui se trouvent à l’intérieur de la chaîne sont conservées.
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
L’exemple suivant supprime les parties de début et de fin de la chaîne `'setuphistorycassettes'` qui correspondent à l’un des caractères de la liste *trim\$1chars* `'tes'`. Tout caractère `t`, `e` ou `s` précédant un autre caractère qui ne figure pas dans la liste *trim\$1chars* au début ou à la fin de la chaîne d’entrée est supprimé.
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# Fonction CONCAT
La fonction CONCAT concatène deux expressions et renvoie l’expression résultante. Pour concaténer plus de deux expressions, utilisez les fonction CONCAT imbriquées. L'opérateur de concaténation (`||`) entre deux expressions donne les mêmes résultats que la fonction CONCAT.
**Note**
Pour la fonction CONCAT et l'opérateur de concaténation, si une expression ou les deux ont la valeur null, le résultat de la concaténation est null.
## Syntaxe
```
CONCAT ( expression1, expression2 )
```
## Arguments
*expression1*, *expression2*
Les deux arguments peuvent être une chaîne de caractères de longueur fixe, une chaîne de caractères de longueur variable, une expression binaire ou une expression qui a pour résultat l’une de ces entrées.
## Type de retour
CONCAT renvoie une expression. Le type de données de l’expression est le même que celui des arguments d’entrée.
Si les expressions d'entrée sont de types différents, AWS Clean Rooms essaie de convertir implicitement l'une des expressions. Si des valeurs ne peuvent pas être converties, une erreur est renvoyée.
## Exemples
L’exemple suivant concatène deux littéraux caractères :
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
La requête suivante, utilisant l’opérateur `||` au lieu de CONCAT, produit le même résultat :
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
L'exemple suivant illustre l'utilisation des fonctions CONCAT pour concaténer trois chaînes de caractères :
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Pour concaténer des colonnes susceptibles de contenir des valeurs nulles, utilisez la fonction [Fonctions NVL et COALESCE](NVL_function.md). L’exemple suivant utilise NVL pour renvoyer un 0 chaque fois que la valeur NULL est rencontrée.
```
select concat(venuename, concat(' seats ', nvl(venueseats, 0))) as seating
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
La requête suivante concatène les valeurs CITY et STATE de la table VENUE :
```
select concat(venuecity, venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
La requête suivante utilise des fonctions CONCAT imbriquées. La requête concatène les valeurs CITY et STATE de la table VENUE, mais délimite la chaîne qui en résulte par une virgule et un espace :
```
select concat(concat(venuecity,', '),venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
# Fonction FORMAT\$1STRING
La fonction FORMAT\$1STRING crée une chaîne formatée en remplaçant les espaces réservés dans une chaîne modèle par les arguments fournis. Elle renvoie une chaîne formatée à partir de chaînes de format de style printf.
La fonction FORMAT\$1STRING fonctionne en remplaçant les espaces réservés dans la chaîne du modèle par les valeurs correspondantes passées en arguments. Ce type de formatage de chaîne peut être utile lorsque vous devez créer dynamiquement des chaînes qui incluent un mélange de texte statique et de données dynamiques, par exemple lors de la génération de messages de sortie, de rapports ou d'autres types de texte informatif. La fonction FORMAT\$1STRING fournit un moyen concis et lisible de créer ces types de chaînes formatées, ce qui facilite la maintenance et la mise à jour du code qui génère le résultat.
## Syntaxe
```
format_string(strfmt, obj, ...)
```
## Arguments
*strfmt*
Expression STRING.
*obj*
Une chaîne ou une expression numérique.
## Type de retour
FORMAT\$1STRING renvoie une chaîne.
## exemple
L'exemple suivant contient un modèle de chaîne contenant deux espaces réservés : `%d` pour une valeur décimale (entier) et `%s` pour une valeur de chaîne. L'`%d`espace réservé est remplacé par la valeur décimale (entier) (`100`), et l'espace réservé %s est remplacé par la valeur de chaîne (). `"days"` La sortie est une chaîne modèle dont les espaces réservés sont remplacés par les arguments fournis :`"Hello World 100 days"`.
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# Fonctions LEFT et RIGHT
Ces fonctions renvoient le nombre de caractères spécifié le plus à gauche ou le plus à droite dans une chaîne de caractères.
Le chiffre est basé sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls.
## Syntaxe
```
LEFT ( string, integer )
RIGHT ( string, integer )
```
## Arguments
*string*
Chaîne de caractères ou expression qui a pour valeur une chaîne de caractères.
*integer*
Nombre entier positif.
## Type de retour
LEFT et RIGHT renvoient une chaîne VARCHAR.
## exemple
L'exemple suivant renvoie les 5 caractères les plus à gauche et les 5 caractères les plus à droite à partir de noms d'événements IDs compris entre 1 000 et 1 005 :
```
select eventid, eventname,
left(eventname,5) as left_5,
right(eventname,5) as right_5
from event
where eventid between 1000 and 1005
order by 1;
eventid | eventname | left_5 | right_5
--------+----------------+--------+---------
1000 | Gypsy | Gypsy | Gypsy
1001 | Chicago | Chica | icago
1002 | The King and I | The K | and I
1003 | Pal Joey | Pal J | Joey
1004 | Grease | Greas | rease
1005 | Chicago | Chica | icago
(6 rows)
```
# Fonction LENGTH
# Fonction LOWER
Convertit une chaîne en minuscules. LOWER prend en charge les caractères à plusieurs octets UTF-8, à concurrence de quatre octets au maximum par caractère.
## Syntaxe
```
LOWER(string)
```
## Argument
*string*
Le paramètre d'entrée est une chaîne VARCHAR (ou tout autre type de données, tel que CHAR, qui peut être implicitement converti en VARCHAR).
## Type de retour
La fonction LOWER renvoie une chaîne de caractères qui est du même type que la chaîne d'entrée.
## Exemples
L'exemple suivant convertit le champ CATNAME en minuscules :
```
select catname, lower(catname) from category order by 1,2;
catname | lower
----------+-----------
Classical | classical
Jazz | jazz
MLB | mlb
MLS | mls
Musicals | musicals
NBA | nba
NFL | nfl
NHL | nhl
Opera | opera
Plays | plays
Pop | pop
(11 rows)
```
# Fonctions LPAD et RPAD
Ces fonctions ajoutent des caractères en préfixe ou en suffixe à une chaîne, en fonction d’une longueur spécifiée.
## Syntaxe
```
LPAD (string1, length, [ string2 ])
```
```
RPAD (string1, length, [ string2 ])
```
## Arguments
*string1*
Chaîne de caractères ou expression qui a pour valeur une chaîne de caractères, comme le nom d'une colonne de caractères.
*longueur*
Nombre entier qui définit la longueur du résultat de la fonction. La longueur d’une chaîne est basée sur le nombre de caractères, pas d’octets, afin que les caractères à plusieurs octets soient comptés comme des caractères seuls. Si *string1* dépasse la longueur spécifiée, il est tronqué (à droite). Si *length* est un nombre négatif, le résultat de la fonction est une chaîne vide.
*string2*
Un ou plusieurs caractères ajoutés en préfixe ou en suffixe à *string1*. Cet argument est facultatif. S'il n'est pas spécifié, les espaces sont utilisés.
## Type de retour
Ces fonctions renvoient un type de données VARCHAR.
## Exemples
Tronquez un ensemble spécifié de noms d'événements à 20 caractères et ajoutez des espaces comme préfixes aux noms plus courts :
```
select lpad(eventname,20) from event
where eventid between 1 and 5 order by 1;
lpad
--------------------
Salome
Il Trovatore
Boris Godunov
Gotterdammerung
La Cenerentola (Cind
(5 rows)
```
Tronquez le même ensemble de noms d'événements à 20 caractères, mais ajoutez `0123456789` comme suffixe aux noms plus courts.
```
select rpad(eventname,20,'0123456789') from event
where eventid between 1 and 5 order by 1;
rpad
--------------------
Boris Godunov0123456
Gotterdammerung01234
Il Trovatore01234567
La Cenerentola (Cind
Salome01234567890123
(5 rows)
```
# Fonction LTRIM
Supprime les caractères du début d’une chaîne de caractères. Supprime la chaîne la plus longue ne contenant que des caractères de la liste des caractères supprimés. Le découpage est terminé lorsqu'aucun caractère de découpage n'apparaît dans la chaîne d'entrée.
## Syntaxe
```
LTRIM( string [, trim_chars] )
```
## Arguments
*string*
Une colonne de chaîne, une expression ou un littéral de chaîne à supprimer.
*trim\$1chars*
Une colonne, une expression ou un littéral de chaîne qui représente les caractères à supprimer au début de la *chaîne*. Si la valeur n’est pas spécifiée, un espace est utilisé comme caractère de séparation.
## Type de retour
La fonction LTRIM renvoie une chaîne de caractères qui est du même type que la *chaîne* d’entrée (CHAR ou VARCHAR).
## Exemples
L’exemple suivant supprime l’année de la colonne `listime`. Les caractères supprimés dans la chaîne littérale `'2008-'` indiquent les caractères à supprimer à partir de la gauche. Si vous utilisez les caractères de suppression `'028-'`, vous obtiendrez le même résultat.
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
LTRIM supprime les caractères de *trim\$1chars* lorsqu’ils apparaissent au début de la *chaîne*. L’exemple suivant supprime les caractères C, D et G lorsqu’ils figurent au début de VENUENAME, qui est une colonne VARCHAR.
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
L’exemple suivant utilise le caractère de suppression `2` qui est extrait de la colonne `venueid`.
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
L’exemple suivant ne supprime aucun caractère car `2` est trouvé avant le caractère de suppression `'0'`.
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
L’exemple suivant utilise le caractère de suppression d’espace par défaut et supprime les deux espaces du début de la chaîne.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# Fonction POSITION
Renvoie l’emplacement de la sous-chaîne spécifiée dans une chaîne.
## Syntaxe
```
POSITION(substring IN string )
```
## Arguments
*substring*
Sous-chaîne à rechercher dans la *chaîne*.
*string*
Chaîne ou colonne à rechercher.
## Type de retour
La fonction POSITION renvoie un nombre entier correspondant à la position de la sous-chaîne (base 1, pas base 0). La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls.
## Notes d’utilisation
POSITION renvoie 0 si la sous-chaîne n'est pas trouvée dans la chaîne POSITION :
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## Exemples
L'exemple suivant montre la position de la chaîne `fish` dans le mot `dogfish` :
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
L'exemple suivant renvoie le nombre de transactions commerciales avec une COMMISSION de plus de 999,00 dans la table SALES :
```
select distinct position('.' in commission), count (position('.' in commission))
from sales where position('.' in commission) > 4 group by position('.' in commission)
order by 1,2;
position | count
---------+-------
5 | 629
(1 row)
```
# Fonction REGEXP\$1COUNT
Recherche un modèle d’expression régulière dans une chaîne et renvoie un nombre entier indiquant le nombre de fois où le modèle est présent dans la chaîne. Si aucune correspondance n'est trouvée, la fonction renvoie 0.
## Syntaxe
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne, comme un nom de colonne, à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieur au nombre de caractères de *source\$1string*, le résultat est 0.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
Entier
## exemple
L'exemple suivant compte le nombre de fois que se produit une séquence de trois lettres.
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
L'exemple suivant compte le nombre de fois que le nom de domaine de niveau supérieur est `org` ou `edu`.
```
SELECT email, regexp_count(email,'@[^.]*\\.(org|edu)')FROM users
ORDER BY userid LIMIT 4;
email | regexp_count
-----------------------------------------------+--------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1
Suspendisse.tristique@nonnisiAenean.edu | 1
amet.faucibus.ut@condimentumegetvolutpat.ca | 0
sed@lacusUtnec.ca | 0
```
L'exemple suivant compte les occurrences de la chaîne `FOX`, en utilisant une correspondance avec respect de la casse.
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
L'exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple compte le nombre d'occurrences de ces mots, avec une correspondance avec respect de la casse.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
L'exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation spécifique au type PCRE. Cet exemple compte le nombre d'occurrences de ces mots, mais diffère de l'exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# Fonction REGEXP\$1INSTR
Recherche un modèle d’expression régulière dans une chaîne et renvoie un nombre entier qui indique la position de début de la sous-chaîne correspondante. Si aucune correspondance n'est trouvée, la fonction renvoie 0. REGEXP\$1SUBSTR est similaire à la fonction [POSITION](POSITION.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne.
## Syntaxe
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne, comme un nom de colonne, à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieur au nombre de caractères de *source\$1string*, le résultat est 0.
*occurrence*
Nombre entier positif qui indique quelle occurrence du modèle utiliser. REGEXP\$1INSTR ignore les *occurrence* -1 premières correspondances. La valeur par défaut est 1. Si *occurrence* est inférieur à 1 ou supérieur au nombre de caractères de la chaîne *source\$1string*, la recherche est ignorée et le résultat est 0.
*option*
Valeur qui indique s'il faut renvoyer la position du premier caractère de la correspondance (`0`) ou celle du premier caractère après la fin de la correspondance (`1`). Toute valeur de chaîne autre que zéro est similaire à la valeur 1. La valeur par défaut est 0.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ e : extraire une sous-chaîne à l’aide d’une sous-expression.
Si *pattern* inclut une sous-expression, REGEXP\$1INSTR met en correspondance une sous-chaîne à l’aide de la première sous-expression incluse dans *pattern*. REGEXP\$1INSTR considère uniquement la première sous-expression ; les autres sous-expressions sont ignorées. Si le modèle n’inclut pas de sous-expression, REGEXP\$1INSTR ignore le paramètre « e ».
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
Entier
## exemple
L'exemple suivant recherche le caractère `@` qui commence par un nom de domaine et renvoie la position de début de la première correspondance.
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
L'exemple suivant recherche des variantes du mot `Center` et renvoie la position du début de la première correspondance.
```
SELECT venuename, regexp_instr(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE regexp_instr(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
venuename | regexp_instr
-----------------------+--------------
The Home Depot Center | 16
Izod Center | 6
Wachovia Center | 10
Air Canada Centre | 12
```
L'exemple suivant recherche la position de départ de la première occurrence de la chaîne `FOX`, à l'aide d'une logique de correspondance avec respect de la casse.
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
L'exemple suivant utilise un modèle écrit en PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple montre comment trouver la position de départ du deuxième mot de ce type.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
L'exemple suivant utilise un modèle écrit en PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple recherche la position de départ du deuxième mot de ce type, mais diffère de l’exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
regexp_instr
--------------
15
```
# Fonction REGEXP\$1REPLACE
Recherche un modèle d’expression régulière dans une chaîne et remplace chaque occurrence du modèle par la chaîne spécifiée. REGEXP\$1REPLACE est similaire à la [Fonction REPLACE](REPLACE.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne.
REGEXP\$1REPLACE est similaire à la [Fonction TRANSLATE](TRANSLATE.md) et la [Fonction REPLACE](REPLACE.md), sauf que TRANSLATE fait plusieurs remplacements de caractère unique et REPLACE remplace une chaîne entière par une autre chaîne, tandis que REGEXP\$1REPLACE vous permet de rechercher un modèle d’expression régulière dans une chaîne.
## Syntaxe
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne, comme un nom de colonne, à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*replace\$1string*
Expression de chaîne, comme un nom de colonne, qui va remplacer chaque occurrence de modèle. La valeur par défaut est une chaîne vide ( "" ).
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieure au nombre de caractères de *source\$1string*, le résultat est *source\$1string*.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
VARCHAR
Si *pattern* ou *replace\$1string* a la valeur NULL, le retour est NULL.
## exemple
L'exemple suivant supprime le caractère `@` et le nom de domaine des adresses e-mail.
```
SELECT email, regexp_replace(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+----------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut
sed@lacusUtnec.ca | sed
```
L'exemple suivant remplace les noms de domaine des adresses e-mail par cette valeur : `internal.company.com`.
```
SELECT email, regexp_replace(email, '@.*\\.[[:alpha:]]{2,3}',
'@internal.company.com') FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+--------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com
sed@lacusUtnec.ca | sed@internal.company.com
```
L'exemple suivant remplace toutes les occurrences de la chaîne `FOX` dans la valeur `quick brown fox`, à l'aide d'une correspondance avec respect de la casse.
```
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'i');
regexp_replace
---------------------
the quick brown fox
```
L'exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple remplace chaque occurrence de mot de ce type par la valeur `[hidden]`.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
L'exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple remplace chaque occurrence de mot de ce type par la valeur `[hidden]`, mais diffère de l'exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# Fonction REGEXP\$1SUBSTR
Renvoie les caractères d’une chaîne en y recherchant un modèle d’expression régulière. REGEXP\$1SUBSTR est similaire à la fonction [Fonction SUBSTRING](SUBSTRING.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne. Si la fonction ne trouve pas correspondance entre l’expression régulière et aucun caractère de la chaîne, elle renvoie une chaîne vide.
## Syntaxe
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieure au nombre de caractères de *source\$1string*, le résultat est une chaîne vide ("").
*occurrence*
Nombre entier positif qui indique quelle occurrence du modèle utiliser. REGEXP\$1SUBSTR ignore les *occurrence* -1 premières correspondances. La valeur par défaut est 1. Si *occurrence* est inférieur à 1 ou supérieur au nombre de caractères de la chaîne *source\$1string*, la recherche est ignorée et le résultat est NULL.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ e : extraire une sous-chaîne à l’aide d’une sous-expression.
Si *pattern* inclut une sous-expression, REGEXP\$1SUBSTR met en correspondance une sous-chaîne à l’aide de la première sous-expression incluse dans *pattern*. Une sous-expression est une expression dans le modèle qui est mise entre parenthèses. Par exemple, le modèle `'This is a (\\w+)'` met en correspondance la première expression avec la chaîne `'This is a '` suivie d’un mot. Au lieu de renvoyer le *modèle*, REGEXP\$1SUBSTR avec le paramètre `e` renvoie uniquement la chaîne contenue dans la sous-expression.
REGEXP\$1SUBSTR considère uniquement la première sous-expression ; les autres sous-expressions sont ignorées. Si le modèle n’inclut pas de sous-expression, REGEXP\$1SUBSTR ignore le paramètre « e ».
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
VARCHAR
## exemple
L’exemple suivant renvoie la partie d’une adresse e-mail comprise entre le caractère @ et l’extension du domaine.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
L'exemple suivant renvoie la partie de l'entrée correspondant à la première occurrence de la chaîne `FOX`, à l'aide d'une correspondance avec respect de la casse.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
L'exemple suivant renvoie la première partie de l'entrée qui commence par des lettres minuscules. Il est fonctionnellement identique à la même instruction SELECT sans le paramètre `c`.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
L’exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple renvoie la partie de l’entrée correspondant au deuxième mot de ce type.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
L’exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l’opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple renvoie la partie de l’entrée correspondant au deuxième mot de ce type, mais diffère de l’exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
L’exemple suivant utilise une sous-expression pour rechercher la deuxième chaîne correspondant au modèle `'this is a (\\w+)'` à l’aide d’une correspondance avec respect de la casse. Il renvoie la sous-expression entre parenthèses.
```
select regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# Fonction REPEAT
Répète une chaîne le nombre de fois spécifié. Si le paramètre d’entrée est numérique, REPEAT le traite sous forme de chaîne.
## Syntaxe
```
REPEAT(string, integer)
```
## Arguments
*string*
Le premier paramètre d’entrée est la chaîne à répéter.
*integer*
Le deuxième paramètre est un nombre entier indiquant combien de fois répéter la chaîne.
## Type de retour
La fonction REPEAT renvoie une chaîne.
## Exemples
L'exemple suivant répète la valeur de la colonne CATID dans la table CATEGORY à trois reprises :
```
select catid, repeat(catid,3)
from category
order by 1,2;
catid | repeat
-------+--------
1 | 111
2 | 222
3 | 333
4 | 444
5 | 555
6 | 666
7 | 777
8 | 888
9 | 999
10 | 101010
11 | 111111
(11 rows)
```
# Fonction REPLACE
Remplace toutes les occurrences d’un jeu de caractères au sein d’une chaîne existante par d’autres caractères spécifiés.
REPLACE est similaire à la [Fonction TRANSLATE](TRANSLATE.md) et la [Fonction REGEXP\$1REPLACE](REGEXP_REPLACE.md), sauf que TRANSLATE fait plusieurs remplacements de caractère unique et REGEXP\$1REPLACE vous permet de rechercher un modèle d’expression régulière dans une chaîne, tandis que REPLACE remplace une chaîne entière par une autre chaîne.
## Syntaxe
```
REPLACE(string1, old_chars, new_chars)
```
## Arguments
*string*
Chaîne CHAR ou VARCHAR à rechercher
*old\$1chars*
Chaîne CHAR ou VARCHAR à remplacer.
*new\$1chars*
Nouvelle chaîne CHAR ou VARCHAR remplaçant l'ancienne chaîne *old\$1string*.
## Type de retour
VARCHAR
Si *old\$1chars* ou *new\$1chars* a la valeur NULL, le retour est NULL.
## Exemples
L'exemple suivant convertit la chaîne `Shows` en `Theatre` dans le champ CATGROUP :
```
select catid, catgroup,
replace(catgroup, 'Shows', 'Theatre')
from category
order by 1,2,3;
catid | catgroup | replace
-------+----------+----------
1 | Sports | Sports
2 | Sports | Sports
3 | Sports | Sports
4 | Sports | Sports
5 | Sports | Sports
6 | Shows | Theatre
7 | Shows | Theatre
8 | Shows | Theatre
9 | Concerts | Concerts
10 | Concerts | Concerts
11 | Concerts | Concerts
(11 rows)
```
# Fonction REVERSE
La fonction REVERSE s’applique à une chaîne et renvoie les caractères dans l’ordre inverse. Par exemple, `reverse('abcde')` renvoie `edcba`. Cette fonction s’applique aux types de données numérique et de date, ainsi qu’aux types de données de caractère. Toutefois, dans la plupart des cas, elle a une valeur pratique pour les chaînes de caractères.
## Syntaxe
```
REVERSE ( expression )
```
## Argument
*expression*
Expression avec un type de données de caractère, date, horodatage ou numérique qui représente la cible de l'inversion de caractères. Toutes les expressions régulières sont implicitement converties en chaînes de caractères de longueur variable. Les espaces de fin des chaînes de caractères à largeur fixe sont ignorés.
## Type de retour
REVERSE renvoie un VARCHAR.
## Exemples
Sélectionnez cinq noms de ville distincts et leur noms inversés correspondants à partir de la table USERS :
```
select distinct city as cityname, reverse(cityname)
from users order by city limit 5;
cityname | reverse
---------+----------
Aberdeen | needrebA
Abilene | enelibA
Ada | adA
Agat | tagA
Agawam | mawagA
(5 rows)
```
Sélectionnez cinq ventes IDs et leur transformation inversée correspondante IDs sous forme de chaînes de caractères :
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# Fonction RTRIM
La fonction RTRIM supprime un ensemble spécifié de caractères à partir de la fin d’une chaîne. Supprime la chaîne la plus longue ne contenant que des caractères de la liste des caractères supprimés. Le découpage est terminé lorsqu'aucun caractère de découpage n'apparaît dans la chaîne d'entrée.
## Syntaxe
```
RTRIM( string, trim_chars )
```
## Arguments
*string*
Une colonne de chaîne, une expression ou un littéral de chaîne à supprimer.
*trim\$1chars*
Colonne de chaîne, expression ou littéral de chaîne représentant les caractères à supprimer à la fin de la *chaîne*. Si la valeur n’est pas spécifiée, un espace est utilisé comme caractère de séparation.
## Type de retour
Chaîne qui a le même type de données que l’argument *string*.
## exemple
L’exemple suivant tronque les espaces de début et de fin de la chaîne `' abc '` :
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L’exemple suivant supprime les chaînes `'xyz'` de fin de la chaîne `'xyzaxyzbxyzcxyz'`. Les occurrences de fin de `'xyz'` sont supprimées, mais celles qui se trouvent à l’intérieur de la chaîne sont conservées.
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
L’exemple suivant supprime les parties de fin de la chaîne `'setuphistorycassettes'` qui correspondent à l’un des caractères de la liste *trim\$1chars* `'tes'`. Tout caractère `t`, `e` ou `s` précédant un autre caractère qui ne figure pas dans la liste *trim\$1chars* à la fin de la chaîne d’entrée est supprimé.
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
L’exemple suivant tronque les caractères « Park » à la fin de VENUENAME le cas échéant :
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
Notez que RTRIM supprime les caractères `P`, `a`, `r` ou `k` lorsqu’ils apparaissent à la fin d’un VENUENAME.
# Fonction SPLIT
La fonction SPLIT vous permet d'extraire des sous-chaînes d'une chaîne plus grande et de les utiliser sous forme de tableau. La fonction SPLIT est utile lorsque vous devez décomposer une chaîne en composants individuels en fonction d'un délimiteur ou d'un modèle spécifique.
## Syntaxe
```
split(str, regex, limit)
```
## Arguments
*str*
Expression de chaîne à diviser.
*regex*
Chaîne représentant une expression régulière. La chaîne *regex* doit être une expression régulière Java.
*limit*
Expression entière qui contrôle le nombre de fois que l'expression *régulière est* appliquée.
+ limit > 0 : la longueur du tableau résultant ne sera pas supérieure à la limite, et la dernière entrée du tableau résultant contiendra toutes les entrées au-delà de la dernière *regex* correspondante.
+ limit <= 0 : *regex* sera appliquée autant de fois que possible, et le tableau résultant peut être de n'importe quelle taille.
## Type de retour
La fonction SPLIT renvoie un ARRAY.
Si `limit > 0` : La longueur du tableau résultant ne sera pas supérieure à la limite, et la dernière entrée du tableau résultant contiendra toutes les entrées au-delà de la dernière expression régulière correspondante.
if `limit <= 0` : regex sera appliquée autant de fois que possible, et le tableau résultant peut être de n'importe quelle taille.
## exemple
Dans cet exemple, la fonction SPLIT divise la chaîne d'entrée `'oneAtwoBthreeC'` là où elle rencontre les caractères `'A'``'B'`, ou `'C'` (comme spécifié par le modèle d'expression régulière`'[ABC]'`). Le résultat obtenu est un tableau de quatre éléments : `"one"``"two"`,`"three"`, et une chaîne vide`""`.
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# Fonction SPLIT\$1PART
Divise une chaîne sur le délimiteur spécifié et renvoie la partie à la position spécifiée.
## Syntaxe
```
SPLIT_PART(string, delimiter, position)
```
## Arguments
*string*
Colonne de chaîne, expression ou littéral de chaîne à fractionner. La chaîne peut être CHAR ou VARCHAR.
*delimiter*
Chaîne de délimiteur indiquant les sections de la *chaîne* d’entrée.
Si *delimiter* est un littéral, mettez-le entre guillemets simples.
*position*
Position de la partie de *chaîne* à renvoyer (à partir de 1). Doit être un nombre entier supérieur à 0. Si la valeur de *position* est supérieure au nombre de parties de chaîne, SPLIT\$1PART renvoie une chaîne vide. Si *délimiteur* est introuvable dans *chaîne*, alors la valeur renvoyée contient le contenu de la partie spécifiée, qui pourrait être la *chaîne* entière ou une valeur vide.
## Type de retour
Chaîne CHAR ou VARCHAR, la même que le paramètre *string*.
## Exemples
L’exemple suivant fractionne un littéral de chaîne en différentes parties en utilisant le délimiteur `$` et renvoie la seconde partie.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
L’exemple suivant fractionne un littéral de chaîne en différentes parties en utilisant le délimiteur `$`. Il renvoie une chaîne vide, car la partie `4` est introuvable.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
L’exemple suivant fractionne un littéral de chaîne en différentes parties en utilisant le délimiteur `#`. Il renvoie la chaîne entière, qui correspond à la première partie, car le délimiteur est introuvable.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
L’exemple suivant divise le champ d’horodatage LISTTIME en composants d’année, de mois et de date.
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
L’exemple suivant sélectionne le champ d’horodatage LISTTIME et le divise sur le caractère `'-'` pour obtenir le mois (la deuxième partie de la chaîne LISTTIME), puis compte le nombre d’entrées de chaque mois :
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# Fonction SUBSTRING
Renvoie le sous-ensemble d’une chaîne sur la base de la position de départ spécifiée.
Si l’entrée est une chaîne de caractères, la position de départ et le nombre de caractères extraits sont basés sur les caractères, pas les octets, afin que les caractères à plusieurs octets soient comptés comme des caractères uniques. Si l’entrée est une expression binaire, la position de départ et la sous-chaîne extraite sont basées sur des octets. Vous ne pouvez pas spécifier de longueur négative, mais vous pouvez spécifier une position de début négative.
## Syntaxe
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Arguments
*chaîne de caractères*
Chaîne à rechercher. Les types de données non-caractères sont traités comme une chaîne.
*start\$1position*
Position au sein de la chaîne à laquelle commencer l’extraction, à partir de 1. La position de début *start\$1position* est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. Ce numéro peut être négatif.
*caractères numériques*
Nombre de caractères à extraire (longueur de la sous-chaîne). Le *nombre de caractères* est basé sur le nombre de caractères, et non sur le nombre d'octets, de sorte que les caractères multi-octets sont considérés comme des caractères uniques. Ce numéro ne peut pas être négatif.
*start\$1byte*
Position au sein de l’expression binaire à laquelle commencer l’extraction, à partir de 1. Ce numéro peut être négatif.
*nombre d'octets*
Nombre d’octets à extraire, c’est-à-dire la longueur de la sous-chaîne. Ce numéro ne peut pas être négatif.
## Type de retour
VARCHAR
## Notes d'utilisation pour les chaînes de caractères
L’exemple suivant renvoie une chaîne de quatre caractères commençant par le sixième caractère.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*Si le *nombre de caractères* *start\$1position* \$1 dépasse la longueur de la *chaîne, SUBSTRING renvoie une sous-chaîne* commençant par la position de départ jusqu'à la fin de la chaîne.* Par exemple :
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
Si `start_position` est négatif ou égal à 0, la fonction SUBSTRING renvoie une sous-chaîne commençant au premier caractère de la chaîne d’une longueur de `start_position` \$1 `numbecharacters` -1. Par exemple :
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Si `start_position` \$1 `numbecharacters` -1 est inférieur ou égal à zéro, SUBSTRING renvoie une chaîne vide. Par exemple :
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## Exemples
L’exemple suivant renvoie le mois de la chaîne LISTTIME dans la table LISTING :
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
L’exemple suivant est le même que ci-dessus, mais utilise l’option FROM...FOR :
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
Vous ne pouvez pas utiliser SUBSTRING pour extraire de manière prévisible le préfixe d’une chaîne pouvant contenir des caractères à plusieurs octets, car vous devez spécifier la longueur d’une chaîne de plusieurs octets basée sur le nombre d’octets, pas sur le nombre de caractères. Pour extraire le segment de début d’une chaîne en fonction de la longueur en octets, vous pouvez utiliser la fonction CAST sur la chaîne au format VARCHAR(*byte\$1length*) pour tronquer la chaîne, où *byte\$1length* est la longueur requise. L’exemple suivant extrait les 5 premiers octets de la chaîne `'Fourscore and seven'`.
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
L’exemple suivant renvoie le prénom `Ana` qui apparaît après le dernier espace de la chaîne d’entrée `Silva, Ana`.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# Fonction TRANSLATE
Pour une expression données, remplace toutes les occurrences de caractères spécifiés par des produits de remplacement spécifiés. Les caractères existants sont mappés à des caractères de remplacement en fonction de leurs positions dans les arguments *characters\$1to\$1replace* et *characters\$1to\$1substitute*. Si le nombre de caractères spécifiés dans l’argument *characters\$1to\$1replace* est supérieur à celui de l’argument *characters\$1to\$1substitute*, les caractères supplémentaires depuis l’argument *characters\$1to\$1replace* sont omis dans la valeur de retour.
TRANSLATE est similaire à la [Fonction REPLACE](REPLACE.md) et la [Fonction REGEXP\$1REPLACE](REGEXP_REPLACE.md), sauf que REPLACE remplace une chaîne entière par une autre chaîne et que REGEXP\$1REPLACE vous permet de rechercher un modèle d’expression régulière dans une chaîne, tandis que TRANSLATE fait plusieurs remplacements de caractère unique.
Si un argument a la valeur null, le retour est NULL.
## Syntaxe
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## Arguments
*expression*
Expression à traduire.
*characters\$1to\$1replace*
Chaîne contenant les caractères à remplacer.
*characters\$1to\$1substitute*
Chaîne contenant les caractères à remplacer.
## Type de retour
VARCHAR
## Exemples
L'exemple suivant remplace plusieurs caractères dans une chaîne :
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
L'exemple suivant remplace le signe (@) par un point dans toutes les valeurs d'une colonne :
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
L'exemple suivant remplace des espaces par des traits de soulignement et supprime les périodes de toutes les valeurs d'une colonne :
```
select city, translate(city, ' .', '_') from users
where city like 'Sain%' or city like 'St%'
group by city
order by city;
city translate
--------------+------------------
Saint Albans Saint_Albans
Saint Cloud Saint_Cloud
Saint Joseph Saint_Joseph
Saint Louis Saint_Louis
Saint Paul Saint_Paul
St. George St_George
St. Marys St_Marys
St. Petersburg St_Petersburg
Stafford Stafford
Stamford Stamford
Stanton Stanton
Starkville Starkville
Statesboro Statesboro
Staunton Staunton
Steubenville Steubenville
Stevens Point Stevens_Point
Stillwater Stillwater
Stockton Stockton
Sturgis Sturgis
```
# Fonction TRIM
Tronque une chaîne en supprimant les espaces de début et de fin ou en supprimant les caractères de début et de fin qui correspondent à une chaîne spécifiée de manière facultative.
## Syntaxe
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## Arguments
*trim\$1chars*
(Facultatif) Caractères à tronquer à partir de la chaîne. Si ce paramètre est oublié, les blancs sont tronqués.
*string*
Chaîne à tronquer.
## Type de retour
La fonction TRIM renvoie une chaîne VARCHAR ou CHAR. Si vous utilisez la fonction TRIM avec une commande SQL, les résultats sont AWS Clean Rooms implicitement convertis en VARCHAR. Si vous utilisez la fonction TRIM dans la liste SELECT pour une fonction SQL, AWS Clean Rooms elle ne convertit pas implicitement les résultats et vous devrez peut-être effectuer une conversion explicite pour éviter une erreur de non-concordance des types de données. Consultez la [Fonction CAST](CAST_function.md) fonction pour plus d'informations sur les conversions explicites.
## exemple
L’exemple suivant tronque les espaces de début et de fin de la chaîne `' abc '` :
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L'exemple suivant supprime les guillemets qui entourent de la chaîne `"dog"` :
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
TRIM supprime les caractères de *trim\$1chars* qui apparaissent au début de la *chaîne*. L'exemple suivant supprime les caractères C, D et G lorsqu'ils figurent au début de VENUENAME, qui est une colonne VARCHAR.
```
select venueid, venuename, trim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
# Fonction UPPER
Convertit la valeur en majuscules. UPPER prend en charge les caractères à plusieurs octets UTF-8, à concurrence de quatre octets au maximum par caractère.
## Syntaxe
```
UPPER(string)
```
## Arguments
*string*
Le paramètre d'entrée est une chaîne VARCHAR (ou tout autre type de données, tel que CHAR, qui peut être implicitement converti en VARCHAR).
## Type de retour
La fonction UPPER renvoie une chaîne de caractères qui est du même type que la chaîne d'entrée.
## Exemples
L'exemple suivant convertit le champ CATNAME en majuscules :
```
select catname, upper(catname) from category order by 1,2;
catname | upper
----------+-----------
Classical | CLASSICAL
Jazz | JAZZ
MLB | MLB
MLS | MLS
Musicals | MUSICALS
NBA | NBA
NFL | NFL
NHL | NHL
Opera | OPERA
Plays | PLAYS
Pop | POP
(11 rows)
```
# Fonction UUID
La fonction UUID génère un identifiant unique universel (UUID).
UUIDs sont des identifiants uniques à l'échelle mondiale qui sont couramment utilisés pour fournir des identifiants uniques à diverses fins, telles que :
+ Identification des enregistrements de base de données ou d'autres entités de données.
+ Génération de noms ou de clés uniques pour des fichiers, des répertoires ou d'autres ressources.
+ Suivi et corrélation des données entre les systèmes distribués.
+ Fournir des identifiants uniques pour les paquets réseau, les composants logiciels ou d'autres actifs numériques.
La fonction UUID génère une valeur UUID unique avec une probabilité très élevée, même sur des systèmes distribués et sur de longues périodes. UUIDs sont généralement générés à l'aide d'une combinaison de l'horodatage actuel, de l'adresse réseau de l'ordinateur et d'autres données aléatoires ou pseudo-aléatoires, ce qui garantit qu'il est très peu probable que chaque UUID généré entre en conflit avec un autre UUID.
Dans le contexte d'une requête SQL, la fonction UUID peut être utilisée pour générer des identifiants uniques pour les nouveaux enregistrements insérés dans une base de données, ou pour fournir des clés uniques pour le partitionnement des données, l'indexation ou à d'autres fins nécessitant un identifiant unique.
**Note**
La fonction UUID n'est pas déterministe.
## Syntaxe
```
uuid()
```
## Arguments
La fonction UUID ne prend aucun argument.
## Type de retour
UUID renvoie une chaîne d'identifiant unique universel (UUID). La valeur est renvoyée sous la forme d'une chaîne UUID canonique de 36 caractères.
## exemple
L'exemple suivant génère un identifiant unique universel (UUID). La sortie est une chaîne de 36 caractères représentant un identifiant unique universel.
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```
# Fonctions liées à la confidentialité
AWS Clean Rooms fournit des fonctions qui vous aident à respecter les spécifications suivantes en matière de respect de la vie privée.
+ **Global Privacy Platform (GPP)** — Spécification de l'Interactive Advertising Bureau (IAB) qui établit un cadre mondial normalisé pour la confidentialité en ligne et l'utilisation des données. Pour plus d'informations sur les spécifications techniques du GPP, consultez la [documentation de la Global Privacy Platform sur GitHub](https://github.com/InteractiveAdvertisingBureau/Global-Privacy-Platform).
+ **Cadre de transparence et de consentement (TCF)** — Élément clé du GPP, lancé en 2020, qui fournit un cadre technique standardisé pour aider les entreprises à se conformer aux réglementations en matière de confidentialité telles que le règlement général sur la protection des données (RGPD) de l'UE. Le TCF permet aux clients d'accorder ou de refuser leur consentement à la collecte et au traitement des données. Pour plus d'informations sur les spécifications techniques du TCF, consultez la [documentation du TCF sur](https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework/tree/master/TCFv2). GitHub
**Topics**
+ [Fonction consent\$1gpp\$1v1\$1decode](consent_gpp_v1_decode.md)
+ [Fonction consent\$1tcf\$1v2\$1decode](consent_tcf_v2_decode.md)
# Fonction consent\$1gpp\$1v1\$1decode
La `consent_gpp_v1_decode` fonction est utilisée pour décoder les données de consentement de la Global Privacy Platform (GPP) v1. Il prend la chaîne de consentement codée en entrée et renvoie les données de consentement décodées, qui incluent des informations sur les préférences de confidentialité et les choix de consentement de l'utilisateur. Cette fonction est utile lorsque vous travaillez avec des données qui incluent des informations de consentement GPP v1, car elle vous permet d'accéder aux données de consentement et de les analyser dans un format structuré.
## Syntaxe
```
consent_gpp_v1_decode(gpp_string)
```
## Arguments
*gpp\$1string*
La chaîne de consentement GPP v1 codée.
## Renvoie
Le dictionnaire renvoyé inclut les paires clé-valeur suivantes :
+ `version`: version de la spécification GPP utilisée (actuellement 1).
+ `cmpId`: ID de la plateforme de gestion du consentement (CMP) qui a codé la chaîne de consentement.
+ `cmpVersion`: version du CMP qui a codé la chaîne de consentement.
+ `consentScreen`: ID de l'écran dans l'interface utilisateur CMP où l'utilisateur a donné son consentement.
+ `consentLanguage`: Le code de langue des informations de consentement.
+ `vendorListVersion`: version de la liste des fournisseurs utilisée.
+ `publisherCountryCode`: le code du pays de l'éditeur.
+ `purposeConsent`: liste d'entiers représentant les objectifs auxquels l'utilisateur a consenti.
+ `purposeLegitimateInterest`: Une liste des objectifs IDs pour lesquels l'intérêt légitime de l'utilisateur a été communiqué de manière transparente.
+ `specialFeatureOptIns`: liste d'entiers représentant les fonctionnalités spéciales que l'utilisateur a choisies.
+ `vendorConsent`: liste des fournisseurs IDs auxquels l'utilisateur a donné son accord.
+ `vendorLegitimateInterest`: Liste des fournisseurs IDs pour lesquels l'intérêt légitime de l'utilisateur a été communiqué de manière transparente.
## exemple
L'exemple suivant prend un seul argument, qui est la chaîne de consentement codée. Il renvoie un dictionnaire contenant les données de consentement décodées, y compris des informations sur les préférences de confidentialité de l'utilisateur, les choix de consentement et d'autres métadonnées.
```
SELECT * FROM consent_gpp_v1_decode('ABCDEFGHIJK');
```
La structure de base des données de consentement renvoyées comprend des informations sur la version de la chaîne de consentement, les détails de la CMP (Consent Management Platform), le consentement de l'utilisateur et les choix d'intérêts légitimes pour différents objectifs et fournisseurs, ainsi que d'autres métadonnées.
```
{
"version": 1,
"cmpId": 12,
"cmpVersion": 34,
"consentScreen": 5,
"consentLanguage": "en",
"vendorListVersion": 89,
"publisherCountryCode": "US",
"purposeConsent": [1],
"purposeLegitimateInterests": [1],
"specialFeatureOptins": [1],
"vendorConsent": [1],
"vendorLegitimateInterests": [1]}
}
```
# Fonction consent\$1tcf\$1v2\$1decode
La `consent_tcf_v2_decode` fonction est utilisée pour décoder les données de consentement du Transparency and Consent Framework (TCF) v2. Il prend la chaîne de consentement codée en entrée et renvoie les données de consentement décodées, qui incluent des informations sur les préférences de confidentialité et les choix de consentement de l'utilisateur. Cette fonction est utile lorsque vous travaillez avec des données qui incluent des informations de consentement TCF v2, car elle vous permet d'accéder aux données de consentement et de les analyser dans un format structuré.
## Syntaxe
```
consent_tcf_v2_decode(tcf_string)
```
## Arguments
*tcf\$1string*
La chaîne de consentement TCF v2 codée.
## Renvoie
La `consent_tcf_v2_decode` fonction renvoie un dictionnaire contenant les données de consentement décodées à partir d'une chaîne de consentement TCF (Transparency and Consent Framework) v2.
Le dictionnaire renvoyé inclut les paires clé-valeur suivantes :
**Segment principal**
+ `version`: version de la spécification TCF utilisée (actuellement 2).
+ `created`: date et heure de création de la chaîne de consentement.
+ `lastUpdated`: date et heure de dernière mise à jour de la chaîne de consentement.
+ `cmpId`: ID de la plateforme de gestion du consentement (CMP) qui a codé la chaîne de consentement.
+ `cmpVersion`: version du CMP qui a codé la chaîne de consentement.
+ `consentScreen`: ID de l'écran dans l'interface utilisateur CMP où l'utilisateur a donné son consentement.
+ `consentLanguage`: Le code de langue des informations de consentement.
+ `vendorListVersion`: version de la liste des fournisseurs utilisée.
+ `tcfPolicyVersion`: version de la politique TCF sur laquelle est basée la chaîne de consentement.
+ `isServiceSpecific`: valeur booléenne indiquant si le consentement est spécifique à un service en particulier ou s'applique à tous les services.
+ `useNonStandardStacks`: valeur booléenne indiquant si des piles non standard sont utilisées.
+ `specialFeatureOptIns`: liste d'entiers représentant les fonctionnalités spéciales que l'utilisateur a choisies.
+ `purposeConsent`: liste d'entiers représentant les objectifs auxquels l'utilisateur a consenti.
+ `purposesLITransparency`: Une liste d'entiers représentant les objectifs pour lesquels l'utilisateur a exprimé un intérêt légitime en termes de transparence.
+ `purposeOneTreatment`: valeur booléenne indiquant si l'utilisateur a demandé le « traitement dans un seul but » (c'est-à-dire que tous les objectifs sont traités de la même manière).
+ `publisherCountryCode`: le code du pays de l'éditeur.
+ `vendorConsent`: liste des fournisseurs IDs auxquels l'utilisateur a donné son accord.
+ `vendorLegitimateInterest`: Liste des fournisseurs IDs pour lesquels l'intérêt légitime de l'utilisateur a été communiqué de manière transparente.
+ `pubRestrictionEntry`: liste des restrictions imposées aux éditeurs. Ce champ contient l'ID d'objectif, le type de restriction et la liste des fournisseurs concernés IDs par cette restriction d'objectif.
**Segment de fournisseurs divulgué**
+ `disclosedVendors`: liste d'entiers représentant les fournisseurs qui ont été divulgués à l'utilisateur.
**Segment destiné aux éditeurs**
+ `pubPurposesConsent`: une liste d'entiers représentant les objectifs spécifiques à l'éditeur pour lesquels l'utilisateur a donné son consentement.
+ `pubPurposesLITransparency`: une liste de nombres entiers représentant les objectifs spécifiques à l'éditeur pour lesquels l'utilisateur a fait preuve de transparence en matière d'intérêts légitimes.
+ `customPurposesConsent`: liste d'entiers représentant les objectifs personnalisés pour lesquels l'utilisateur a donné son consentement.
+ `customPurposesLITransparency`: Une liste d'entiers représentant les objectifs personnalisés pour lesquels l'utilisateur a accordé la transparence à ses intérêts légitimes.
Ces données de consentement détaillées peuvent être utilisées pour comprendre et respecter les préférences de confidentialité de l'utilisateur lorsqu'il travaille avec des données personnelles.
## exemple
L'exemple suivant prend un seul argument, qui est la chaîne de consentement codée. Il renvoie un dictionnaire contenant les données de consentement décodées, y compris des informations sur les préférences de confidentialité de l'utilisateur, les choix de consentement et d'autres métadonnées.
```
from aws_clean_rooms.functions import consent_tcf_v2_decode
consent_string = "CO1234567890abcdef"
consent_data = consent_tcf_v2_decode(consent_string)
print(consent_data)
```
La structure de base des données de consentement renvoyées comprend des informations sur la version de la chaîne de consentement, les détails de la CMP (Consent Management Platform), le consentement de l'utilisateur et les choix d'intérêts légitimes pour différents objectifs et fournisseurs, ainsi que d'autres métadonnées.
```
/** core segment **/
version: 2,
created: "2023-10-01T12:00:00Z",
lastUpdated: "2023-10-01T12:00:00Z",
cmpId: 1234,
cmpVersion: 5,
consentScreen: 1,
consentLanguage: "en",
vendorListVersion: 2,
tcfPolicyVersion: 2,
isServiceSpecific: false,
useNonStandardStacks: false,
specialFeatureOptIns: [1, 2, 3],
purposeConsent: [1, 2, 3],
purposesLITransparency: [1, 2, 3],
purposeOneTreatment: true,
publisherCountryCode: "US",
vendorConsent: [1, 2, 3],
vendorLegitimateInterest: [1, 2, 3],
pubRestrictionEntry: [
{ purpose: 1, restrictionType: 2, restrictionDescription: "Example restriction" },
],
/** disclosed vendor segment **/
disclosedVendors: [1, 2, 3],
/** publisher purposes segment **/
pubPurposesConsent: [1, 2, 3],
pubPurposesLITransparency: [1, 2, 3],
customPurposesConsent: [1, 2, 3],
customPurposesLITransparency: [1, 2, 3],
};
```
# Fonctions de fenêtrage
En utilisant les fonctions de fenêtrage, vous pouvez créer des requêtes d’analyse commerciale plus efficacement. Les fonctions de fenêtrage fonctionnent sur une partition ou « fenêtre » d’un ensemble de résultats et renvoient une valeur pour chaque ligne de cette fenêtre. En revanche, les fonctions non fenêtrées effectuent leurs calculs sur chaque ligne du jeu de résultats. Contrairement aux fonctions de groupe qui regroupent les lignes de résultats, les fonctions de fenêtrage conservent toutes les lignes de l’expression de table.
Les valeurs renvoyées sont calculées en utilisant les valeurs des ensembles de lignes de cette fenêtre. Pour chaque ligne de la table, la fenêtre définit un ensemble de lignes qui est utilisé pour calculer des attributs supplémentaires. Une fenêtre est définie à l’aide d’une spécification de fenêtrage (clause OVER) et s’appuie sur trois concepts principaux :
+ Le *partitionnement de fenêtrage* qui constitue des groupes de lignes (clause PARTITION)
+ L’*ordonnancement de fenêtrage*, qui définit un ordre ou une séquence de lignes dans chaque partition (clause ORDER BY)
+ Les *cadres de fenêtrage*, qui sont définis par rapport à chaque ligne afin de limiter davantage l’ensemble de lignes (spécification ROWS)
Les fonctions de fenêtrage constituent le dernier ensemble d’opérations effectuées dans une requête à l’exception de la clause ORDER BY finale. Toutes les jointures et toutes les clauses WHERE, GROUP BY et HAVING doivent être terminées avant que les fonctions de fenêtrage soient traitées. Par conséquent, les fonctions de fenêtrage peuvent s’afficher uniquement dans la liste de sélection ou la clause ORDER BY. Vous pouvez utiliser plusieurs fonctions de fenêtrage dans une seule requête avec différentes clauses de cadre. Vous pouvez également utiliser des fonctions de fenêtrage dans d’autres expressions scalaires, telles que CASE.
## Récapitulatif de la syntaxe de la fonction de fenêtrage
Les fonctions de fenêtre suivent la syntaxe standard suivante.
```
function (expression) OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list [ frame_clause ] ] )
```
Ici, *function* est l’une des fonctions décrites dans cette section.
L’*expr\$1list* se présente comme suit.
```
expression | column_name [, expr_list ]
```
L’*order\$1list* se présente comme suit.
```
expression | column_name [ ASC | DESC ]
[ NULLS FIRST | NULLS LAST ]
[, order_list ]
```
La *frame\$1clause* se présente comme suit.
```
ROWS
{ UNBOUNDED PRECEDING | unsigned_value PRECEDING | CURRENT ROW } |
{ BETWEEN
{ UNBOUNDED PRECEDING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW}
AND
{ UNBOUNDED FOLLOWING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW }}
```
### Arguments
*fonction*
La fonction de fenêtrage. Pour plus d’informations, consultez les descriptions de chaque fonction.
OVER
La clause qui définit la spécification du fenêtrage. La clause OVER est obligatoire pour les fonctions de fenêtrage et différencie les fonctions de fenêtrage d’autres fonctions SQL.
PARTITION BY *expr\$1list*
(Facultatif) La clause PARTITION BY subdivise le jeu de résultats en partitions, comme la clause GROUP BY. Si une clause de partition est présente, la fonction est calculée pour les lignes de chaque partition. Si aucune clause de partition n’est spécifiée, une seule partition contient la totalité de la table et la fonction est calculée pour cette table complète.
Les fonctions de rang DENSE\$1RANK, NTILE, RANK et ROW\$1NUMBER, nécessitent une comparaison globale de toutes les lignes du jeu de résultats. Lorsqu’une clause PARTITION BY est utilisée, l’optimiseur de requête peut exécuter chaque agrégation en parallèle en répartissant la charge de travail sur plusieurs tranches selon les partitions. Si la clause PARTITION BY n’est pas présente, l’étape d’agrégation doit être exécutée en série sur une seule tranche, ce qui peut avoir une incidence négative importante sur les performances, surtout pour des clusters de grande taille.
AWS Clean Roomsne prend pas en charge les littéraux de chaîne dans les clauses PARTITION BY.
ORDER BY *order\$1list*
(Facultatif) La fonction de fenêtrage est appliquée aux lignes de chaque partition triées selon la spécification d’ordre de ORDER BY. Cette clause ORDER BY est distincte et sans aucun lien avec une clause ORDER BY dans la *frame\$1clause*. La clause ORDER BY peut être utilisée sans la clause PARTITION BY.
Pour les fonctions de rang, la clause ORDER BY identifie les mesures des valeurs de rang. Pour les fonctions d’agrégation, les lignes partitionnées doivent être ordonnées avant que la fonction d’agrégation soit calculée pour chaque cadre. Pour en savoir plus sur les types de fonction de fenêtrage, consultez [Fonctions de fenêtrage](#Window_functions).
Les identificateurs de colonnes ou les expressions qui correspondent aux identificateurs de colonnes sont requis dans la liste d’ordre. Ni les constantes, ni les expressions constantes ne peuvent être utilisées pour remplacer les noms de colonnes.
Les valeurs NULLS sont traitées comme leur propre groupe, triées et classées selon l’option NULLS FIRST ou NULLS LAST. Par défaut, les valeurs NULL sont triées et classées en dernier par ordre croissant (ASC) et triées et classées en premier par ordre décroissant (DESC).
AWS Clean Roomsne prend pas en charge les littéraux de chaîne dans les clauses ORDER BY.
Si la clause ORDER BY est omise, l’ordre des lignes est non déterministe.
Dans tout système parallèleAWS Clean Rooms, par exemple lorsqu'une clause ORDER BY ne produit pas un ordre unique et total des données, l'ordre des lignes n'est pas déterministe. En d'autres termes, si l'expression ORDER BY produit des valeurs dupliquées (ordre partiel), l'ordre de retour de ces lignes peut varier d'une exécution AWS Clean Rooms à l'autre. De leur côté, les fonctions de fenêtrage peuvent renvoyer des résultats inattendus ou incohérents. Pour de plus amples informations, veuillez consulter [Ordonnancement unique des données pour les fonctions de fenêtrage](#Examples_order_by_WF).
*column\$1name*
Nom d’une colonne à partitionner ou à ordonner.
ASC \$1 DESC
Option qui définit l’ordre de tri de l’expression, comme suit :
+ ASC : croissant (par exemple, de faible à élevé pour les valeurs numériques et de « A » à « Z » pour les chaînes de caractères). Si aucune option n’est spécifiée, les données sont triées dans l’ordre croissant par défaut.
+ DESC : descendantes (valeurs d’élevées à faibles pour les valeurs numériques ; de « Z » à « A » pour les chaînes).
NULLS FIRST \$1 NULLS LAST
Option qui spécifie si les valeurs NULLS devraient être classés en premier, avant les valeurs non NULL, ou en dernier, après les valeurs non NULL. Par défaut, les valeurs NULLS sont triées et classées en dernier par ordre croissant (ASC) et triées et classées en premier par ordre décroissant (DESC).
*frame\$1clause*
Pour les fonctions d’agrégation, la clause de cadre affine l’ensemble de lignes dans la fenêtre d’une fonction lorsque vous utilisez ORDER BY. Elle vous permet d’inclure ou d’exclure des ensembles de lignes dans le résultat ordonné. La clause de cadre se compose du mot-clé ROWS et des spécificateurs associés.
La clause frame ne s’applique pas aux fonctions de classement. En outre, la clause de cadre n’est pas requise lorsqu’aucune clause ORDER BY n’est utilisée dans la clause OVER pour une fonction d’agrégation. Si une clause ORDER BY est utilisée pour une fonction d’agrégation, une clause de cadre explicite est requise.
Si aucune clause ORDER BY n’est spécifiée, le cadre implicite est sans limite : équivalent à ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING.
ROWS
Cette clause définit le cadre de fenêtrage en spécifiant un décalage physique de la ligne actuelle.
Cette clause spécifie les lignes de la fenêtre ou de la partition actuelle auxquelles la valeur de la ligne actuelle doit être associée. Elle utilise des arguments qui spécifient la position de la ligne, qui peut être avant ou après la ligne actuelle. Le point de référence de tous les cadres de fenêtrage est la ligne actuelle. Chaque ligne devient la ligne actuelle à son tour à mesure que le cadre de fenêtrage avance dans la partition.
Le cadre peut être un simple ensemble de lignes allant jusqu’à et incluant la ligne actuelle.
```
{UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW}
```
Ou il peut s’agir d’un ensemble de lignes situées entre les deux limites.
```
BETWEEN
{ UNBOUNDED PRECEDING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
AND
{ UNBOUNDED FOLLOWING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
```
UNBOUNDED PRECEDING indique que la fenêtre commence à la première ligne de la partition ; *offset* PRECEDING indique que la fenêtre commence un certain nombre de lignes équivalant à la valeur de décalage avant la ligne actuelle. UNBOUNDED PRECEDING est la valeur par défaut.
CURRENT ROW indique que la fenêtre commence ou se termine à la ligne actuelle.
UNBOUNDED FOLLOWING indique que la fenêtre se termine à la dernière ligne de la partition ; *offset* FOLLOWING indique que la fenêtre se termine un certain nombre de lignes équivalant à la valeur de décalage après la ligne actuelle.
*offset* identifie un nombre physique de lignes avant ou après la ligne actuelle. Dans ce cas, *offset* doit être une constante ayant une valeur numérique positive. Par exemple, 5 FOLLOWING arrête les 5 lignes du cadre après la ligne actuelle.
Là où BETWEEN n’est pas spécifié, le cadre est implicitement délimité par la ligne actuelle. Par exemple, `ROWS 5 PRECEDING` est égal à `ROWS BETWEEN 5 PRECEDING AND CURRENT ROW`. En outre, `ROWS UNBOUNDED FOLLOWING` est égal à `ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING`.
Vous ne pouvez pas spécifier un cadre dans lequel la limite de début est supérieure à la limite de fin. Par exemple, vous ne pouvez pas spécifier l’un des cadres suivants.
```
between 5 following and 5 preceding
between current row and 2 preceding
between 3 following and current row
```
## Ordonnancement unique des données pour les fonctions de fenêtrage
Si une clause ORDER BY pour une fonction de fenêtrage ne génère pas d’ordonnancement unique et total des données, l’ordre des lignes est non déterministe. Si l’expression ORDER BY génère des valeurs en double (ordonnancement partiel), l’ordre de ces lignes qui est renvoyé peut varier lors de plusieurs exécutions. Dans ce cas, les fonctions de fenêtrage peuvent également renvoyer des résultats inattendus ou incohérents.
Par exemple, la requête suivante renvoie des résultats différents sur plusieurs exécutions. Ces différents résultats se produisent parce que `order by dateid` ne produit pas d’ordonnancement unique des données pour la fonction de fenêtrage SUM.
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 1730.00 | 1730.00
1827 | 708.00 | 2438.00
1827 | 234.00 | 2672.00
...
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 234.00 | 234.00
1827 | 472.00 | 706.00
1827 | 347.00 | 1053.00
...
```
Dans ce cas, l’ajout d’une seconde colonne ORDER BY à la fonction de fenêtrage peut permettre de résoudre le problème.
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid, pricepaid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+---------
1827 | 234.00 | 234.00
1827 | 337.00 | 571.00
1827 | 347.00 | 918.00
...
```
## Fonctions prises en charge
AWS Clean RoomsSpark SQL prend en charge deux types de fonctions de fenêtre : l'agrégation et le classement.
Vous trouverez ci-dessous les fonctions d’agrégation prises en charge :
+ [Fonction de fenêtrage CUME\$1DIST](WF_CUME_DIST.md)
+ [Fonction de fenêtrage DENSE\$1RANK](WF_DENSE_RANK.md)
+ [Fonction de fenêtre FIRST](WF_FIRST.md)
+ [Fonction de fenêtrage FIRST\$1VALUE](WF_first_value.md)
+ [Fonction de fenêtrage LAG](WF_LAG.md)
+ [Fonction LAST window](WF-LAST.md)
+ [Fonction de fenêtrage LAST\$1VALUE](WF_last_value.md)
+ [Fonction de fenêtrage LEAD](WF_LEAD.md)
Vous trouverez ci-dessous les fonctions de classement prises en charge :
+ [Fonction de fenêtrage DENSE\$1RANK](WF_DENSE_RANK.md)
+ [Fonction de fenêtrage PERCENT\$1RANK](WF_PERCENT_RANK.md)
+ [Fonction de fenêtrage RANK](WF_RANK.md)
+ [Fonction de fenêtrage ROW\$1NUMBER](WF_ROW_NUMBER.md)
## Exemple de tableau contenant des exemples de fonctions de fenêtrage
Vous trouverez des exemples de fonctions de fenêtrage spécifiques avec la description de chaque fonction. Certains exemples utilisent une table nommée WINSALES, qui contient 11 lignes, comme indiqué dans le tableau suivant.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/clean-rooms/latest/sql-reference/Window_functions.html)
# Fonction de fenêtrage CUME\$1DIST
Calcule la distribution cumulée d’une valeur au sein d’une fenêtre ou une partition. En supposant que l’ordre est croissant, la distribution cumulée est déterminée à l’aide de la formule suivante :
`count of rows with values <= x / count of rows in the window or partition`
où *x* est égal à la valeur de la ligne actuelle de la colonne spécifiée dans la clause ORDER BY. Le jeu de données suivant illustre l’utilisation de cette formule :
```
Row# Value Calculation CUME_DIST
1 2500 (1)/(5) 0.2
2 2600 (2)/(5) 0.4
3 2800 (3)/(5) 0.6
4 2900 (4)/(5) 0.8
5 3100 (5)/(5) 1.0
```
La plage de valeur de retour est comprise entre >0 et 1, inclus.
## Syntaxe
```
CUME_DIST ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Arguments
OVER
Clause qui spécifie le partitionnement de fenêtrage. La clause OVER ne peut pas contenir de spécification de cadre de fenêtrage.
PARTITION BY *partition\$1expression*
Facultatif. Expression qui définit la plage d’enregistrements de chaque groupe dans la clause OVER.
ORDER BY *order\$1list*
Expression permettant de calculer la distribution cumulée. L’expression doit disposer d’un type de données numériques ou être convertible implicitement en une. Si ORDER BY n’est pas spécifié, la valeur de retour est 1 pour toutes les lignes.
Si ORDER BY ne génère pas d’ordonnancement unique, l’ordre des lignes est non déterministe. Pour de plus amples informations, veuillez consulter [Ordonnancement unique des données pour les fonctions de fenêtrage](Window_functions.md#Examples_order_by_WF).
## Type de retour
FLOAT8
## Exemples
L’exemple suivant calcule la distribution cumulée de la quantité par vendeur :
```
select sellerid, qty, cume_dist()
over (partition by sellerid order by qty)
from winsales;
sellerid qty cume_dist
--------------------------------------------------
1 10.00 0.33
1 10.64 0.67
1 30.37 1
3 10.04 0.25
3 15.15 0.5
3 20.75 0.75
3 30.55 1
2 20.09 0.5
2 20.12 1
4 10.12 0.5
4 40.23 1
```
Pour obtenir une description de la table WINSALES, consultez [Exemple de tableau contenant des exemples de fonctions de fenêtrage](Window_functions.md#Window_function_example).
# Fonction de fenêtrage DENSE\$1RANK
La fonction de fenêtrage DENSE\$1RANK détermine le rang d’une valeur dans un groupe de valeurs, en fonction de l’expression ORDER BY dans la clause OVER. Si la clause PARTITION BY facultative est présente, les rangs sont réinitialisés pour chaque groupe de lignes. Les lignes avec des valeurs égales pour les critères de rang reçoivent le même rang. La fonction DENSE\$1RANK diffère de RANK sur un point : si deux lignes ou plus sont à égalité, il n'y a pas d'écart dans la séquence des valeurs classées. Par exemple, si deux lignes sont classées 1, le prochain rang est 2.
Vous pouvez avoir des fonctions de rang avec différentes clauses PARTITION BY et ORDER BY dans la même requête.
## Syntaxe
```
DENSE_RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Arguments
( )
La fonction ne prend pas d’arguments, mais les parenthèses vides sont obligatoires.
OVER
Clauses de fenêtrage pour la fonction DENSE\$1RANK.
PARTITION BY *expr\$1list*
Facultatif. Une ou plusieurs expressions qui définissent le fenêtrage.
ORDER BY *order\$1list*
Facultatif. Expression sur laquelle sont basées les valeurs de rang. Si aucune clause PARTITION BY n’est spécifiée, ORDER BY utilise toute la table. Si ORDER BY n’est pas spécifié, la valeur de retour est 1 pour toutes les lignes.
Si ORDER BY ne génère pas d’ordonnancement unique, l’ordre des lignes est non déterministe. Pour de plus amples informations, veuillez consulter [Ordonnancement unique des données pour les fonctions de fenêtrage](Window_functions.md#Examples_order_by_WF).
## Type de retour
INTEGER
## Exemples
L'exemple suivant montre le classement de la table en fonction de la quantité vendue (par ordre décroissant) et l'affectation d'un rang dense et d'un rang standard à chaque ligne. Les résultats sont triés une fois que les résultats de la fonction de fenêtrage sont appliqués.
```
select salesid, qty,
dense_rank() over(order by qty desc) as d_rnk,
rank() over(order by qty desc) as rnk
from winsales
order by 2,1;
salesid | qty | d_rnk | rnk
---------+-----+-------+-----
10001 | 10 | 5 | 8
10006 | 10 | 5 | 8
30001 | 10 | 5 | 8
40005 | 10 | 5 | 8
30003 | 15 | 4 | 7
20001 | 20 | 3 | 4
20002 | 20 | 3 | 4
30004 | 20 | 3 | 4
10005 | 30 | 2 | 2
30007 | 30 | 2 | 2
40001 | 40 | 1 | 1
(11 rows)
```
Notez la différence entre les rangs affectés au même ensemble de lignes lorsque les fonctions DENSE\$1RANK et RANK sont utilisées côte à côte dans la même requête. Pour obtenir une description de la table WINSALES, consultez [Exemple de tableau contenant des exemples de fonctions de fenêtrage](Window_functions.md#Window_function_example).
L'exemple suivant montre le partitionnement de la table en fonction de chaque SELLERID, le classement de chaque partition selon la quantité (par ordre décroissant) et l'affectation d'un rang dense à chaque ligne. Les résultats sont triés une fois que les résultats de la fonction de fenêtrage sont appliqués.
```
select salesid, sellerid, qty,
dense_rank() over(partition by sellerid order by qty desc) as d_rnk
from winsales
order by 2,3,1;
salesid | sellerid | qty | d_rnk
---------+----------+-----+-------
10001 | 1 | 10 | 2
10006 | 1 | 10 | 2
10005 | 1 | 30 | 1
20001 | 2 | 20 | 1
20002 | 2 | 20 | 1
30001 | 3 | 10 | 4
30003 | 3 | 15 | 3
30004 | 3 | 20 | 2
30007 | 3 | 30 | 1
40005 | 4 | 10 | 2
40001 | 4 | 40 | 1
(11 rows)
```
Pour obtenir une description de la table WINSALES, consultez [Exemple de tableau contenant des exemples de fonctions de fenêtrage](Window_functions.md#Window_function_example).
# Fonction de fenêtre FIRST
À partir d'un ensemble ordonné de lignes, FIRST renvoie la valeur de l'expression spécifiée par rapport à la première ligne du cadre de fenêtre.
Pour savoir comment sélectionner la dernière ligne du cadre, consultez [Fonction LAST window](WF-LAST.md).
## Syntaxe
```
FIRST( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère.
IGNORE NULLS
Lorsque cette option est utilisée avec FIRST, la fonction renvoie la première valeur du cadre qui n'est pas NULL (ou NULL si toutes les valeurs sont NULL).
RESPECT NULLS
Indique que les valeurs nulles AWS Clean Rooms doivent être incluses dans la détermination de la ligne à utiliser. La clause RESPECT NULLS est prise en charge par défaut, si vous ne spécifiez pas IGNORE NULLS.
OVER
Présente les clauses de fenêtrage de la fonction.
PARTITION BY *expr\$1list*
Définit la fenêtre de la fonction en termes d’une ou de plusieurs expressions.
ORDER BY *order\$1list*
Trie les lignes dans chaque partition. Si aucune clause PARTITION BY n’est spécifiée, ORDER BY trie toute la table. Si vous spécifiez une clause ORDER BY, vous devez également spécifier une *frame\$1clause*.
Les résultats de la fonction FIRST dépendent de l'ordre des données. Les résultats sont non déterministes dans les cas suivants :
+ Quand aucune clause ORDER BY n’est spécifiée et qu’une partition contient deux valeurs différentes pour une expression
+ Lorsque l’expression a des valeurs différentes qui correspondent à la même valeur dans la liste ORDER BY.
*frame\$1clause*
Si une clause ORDER BY est utilisée pour une fonction d’agrégation, une clause de cadre explicite est requise. La clause de cadre affine l’ensemble de lignes dans la fenêtre d’une fonction, en incluant ou en excluant des ensembles de lignes du résultat ordonné. La clause de cadre se compose du mot-clé ROWS et des spécificateurs associés. Consultez [Récapitulatif de la syntaxe de la fonction de fenêtrage](Window_functions.md#Window_function_synopsis).
## Type de retour
Ces fonctions prennent en charge les expressions qui utilisent des types de AWS Clean Rooms données primitifs. Le type de retour est identique au type de données de l’*expression*.
## Exemples
L’exemple suivant renvoie le nombre de places de chaque site dans la table VENUE, avec les résultats classés par capacité (d’élevée à faible). La fonction FIRST permet de sélectionner le nom du lieu qui correspond à la première ligne du cadre : dans ce cas, la rangée avec le plus grand nombre de places. Les résultats sont partitionnés par État, lorsque la valeur VENUESTATE change, une nouvelle première valeur est donc sélectionnée. Le cadre de fenêtrage est illimité. La même première valeur est donc sélectionnée pour chaque ligne de chaque partition.
Pour la Californie, `Qualcomm Stadium` possède le plus grand nombre de places (`70561`), ce nom est donc la première valeur de toutes les lignes dans la partition `CA`.
```
select venuestate, venueseats, venuename,
first(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
CA | 63026 | McAfee Coliseum | Qualcomm Stadium
CA | 56000 | Dodger Stadium | Qualcomm Stadium
CA | 45050 | Angel Stadium of Anaheim | Qualcomm Stadium
CA | 42445 | PETCO Park | Qualcomm Stadium
CA | 41503 | AT&T Park | Qualcomm Stadium
CA | 22000 | Shoreline Amphitheatre | Qualcomm Stadium
CO | 76125 | INVESCO Field | INVESCO Field
CO | 50445 | Coors Field | INVESCO Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Dolphin Stadium
FL | 73800 | Jacksonville Municipal Stadium | Dolphin Stadium
FL | 65647 | Raymond James Stadium | Dolphin Stadium
FL | 36048 | Tropicana Field | Dolphin Stadium
...
```
# Fonction de fenêtrage FIRST\$1VALUE
Étant donné un ensemble de lignes ordonné, FIRST\$1VALUE renvoie la valeur de l’expression spécifiée concernant la première ligne du cadre de fenêtrage d’un ensemble de lignes ordonné.
Pour savoir comment sélectionner la dernière ligne du cadre, consultez [Fonction de fenêtrage LAST\$1VALUE](WF_last_value.md).
## Syntaxe
```
FIRST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère.
IGNORE NULLS
Lorsque cette option est utilisée avec FIRST\$1VALUE, la fonction renvoie la première valeur du cadre qui n’est pas NULL (ou NULL si toutes les valeurs sont NULL).
RESPECT NULLS
Indique que les valeurs nulles AWS Clean Rooms doivent être incluses dans la détermination de la ligne à utiliser. La clause RESPECT NULLS est prise en charge par défaut, si vous ne spécifiez pas IGNORE NULLS.
OVER
Présente les clauses de fenêtrage de la fonction.
PARTITION BY *expr\$1list*
Définit la fenêtre de la fonction en termes d’une ou de plusieurs expressions.
ORDER BY *order\$1list*
Trie les lignes dans chaque partition. Si aucune clause PARTITION BY n’est spécifiée, ORDER BY trie toute la table. Si vous spécifiez une clause ORDER BY, vous devez également spécifier une *frame\$1clause*.
Les résultats de la fonction FIRST\$1VALUE dépendent de l’ordre des données. Les résultats sont non déterministes dans les cas suivants :
+ Quand aucune clause ORDER BY n’est spécifiée et qu’une partition contient deux valeurs différentes pour une expression
+ Lorsque l’expression a des valeurs différentes qui correspondent à la même valeur dans la liste ORDER BY.
*frame\$1clause*
Si une clause ORDER BY est utilisée pour une fonction d’agrégation, une clause de cadre explicite est requise. La clause de cadre affine l’ensemble de lignes dans la fenêtre d’une fonction, en incluant ou en excluant des ensembles de lignes du résultat ordonné. La clause de cadre se compose du mot-clé ROWS et des spécificateurs associés. Consultez [Récapitulatif de la syntaxe de la fonction de fenêtrage](Window_functions.md#Window_function_synopsis).
## Type de retour
Ces fonctions prennent en charge les expressions qui utilisent des types de AWS Clean Rooms données primitifs. Le type de retour est identique au type de données de l’*expression*.
## Exemples
L’exemple suivant renvoie le nombre de places de chaque site dans la table VENUE, avec les résultats classés par capacité (d’élevée à faible). La fonction FIRST\$1VALUE permet de sélectionner le nom du lieu qui correspond à la première ligne du cadre : dans le cas présent, la ligne comportant le plus grand nombre de places. Les résultats sont partitionnés par État, lorsque la valeur VENUESTATE change, une nouvelle première valeur est donc sélectionnée. Le cadre de fenêtrage est illimité. La même première valeur est donc sélectionnée pour chaque ligne de chaque partition.
Pour la Californie, `Qualcomm Stadium` possède le plus grand nombre de places (`70561`), ce nom est donc la première valeur de toutes les lignes dans la partition `CA`.
```
select venuestate, venueseats, venuename,
first_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
CA | 63026 | McAfee Coliseum | Qualcomm Stadium
CA | 56000 | Dodger Stadium | Qualcomm Stadium
CA | 45050 | Angel Stadium of Anaheim | Qualcomm Stadium
CA | 42445 | PETCO Park | Qualcomm Stadium
CA | 41503 | AT&T Park | Qualcomm Stadium
CA | 22000 | Shoreline Amphitheatre | Qualcomm Stadium
CO | 76125 | INVESCO Field | INVESCO Field
CO | 50445 | Coors Field | INVESCO Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Dolphin Stadium
FL | 73800 | Jacksonville Municipal Stadium | Dolphin Stadium
FL | 65647 | Raymond James Stadium | Dolphin Stadium
FL | 36048 | Tropicana Field | Dolphin Stadium
...
```
# Fonction de fenêtrage LAG
La fonction de fenêtrage LAG renvoie les valeurs pour une ligne avec un décalage donné au-dessus (avant) de la ligne actuelle dans la partition.
## Syntaxe
```
LAG (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Arguments
*value\$1expr*
Colonne cible ou expression sur laquelle la fonction opère.
*offset*
Paramètre facultatif qui spécifie le nombre de lignes avant la ligne actuelle pour lesquelles renvoyer des valeurs. Le décalage peut être un nombre entier constant ou une expression qui a pour valeur un nombre entier. Si vous ne spécifiez pas de décalage, AWS Clean Rooms utilisez `1` comme valeur par défaut. Un décalage de `0` indique la ligne actuelle.
IGNORE NULLS
Spécification facultative qui indique que les valeurs nulles AWS Clean Rooms doivent être ignorées lors de la détermination de la ligne à utiliser. Les valeurs NULL sont incluses si IGNORE NULLS n’est pas répertorié.
Vous pouvez utiliser une expression NVL ou COALESCE pour remplacer les valeurs NULL par une autre valeur.
RESPECT NULLS
Indique que les valeurs nulles AWS Clean Rooms doivent être incluses dans la détermination de la ligne à utiliser. La clause RESPECT NULLS est prise en charge par défaut, si vous ne spécifiez pas IGNORE NULLS.
OVER
Spécifie le partitionnement de fenêtrage et d’ordonnancement. La clause OVER ne peut pas contenir de spécification de cadre de fenêtrage.
PARTITION BY *window\$1partition*
Argument facultatif qui définit la plage d’enregistrements de chaque groupe de la clause OVER.
ORDER BY *window\$1ordering*
Trie les lignes dans chaque partition.
La fonction de fenêtre LAG prend en charge les expressions qui utilisent n'importe quel type de AWS Clean Rooms données. Le type de retour est identique au type *value\$1expr*.
## Exemples
L’exemple suivant présente la quantité de billets vendus à l’acheteur ayant l’ID d’acheteur 3 et l’heure à laquelle l’acheteur 3 a acheté les billets. Pour comparer chaque vente à la vente précédente de l’acheteur 3, la requête renvoie la quantité précédente vendue pour chaque vente. Dans la mesure où il n’y a aucun achat avant le 16/01/2008, la première quantité précédente vendue a la valeur null :
```
select buyerid, saletime, qtysold,
lag(qtysold,1) over (order by buyerid, saletime) as prev_qtysold
from sales where buyerid = 3 order by buyerid, saletime;
buyerid | saletime | qtysold | prev_qtysold
---------+---------------------+---------+--------------
3 | 2008-01-16 01:06:09 | 1 |
3 | 2008-01-28 02:10:01 | 1 | 1
3 | 2008-03-12 10:39:53 | 1 | 1
3 | 2008-03-13 02:56:07 | 1 | 1
3 | 2008-03-29 08:21:39 | 2 | 1
3 | 2008-04-27 02:39:01 | 1 | 2
3 | 2008-08-16 07:04:37 | 2 | 1
3 | 2008-08-22 11:45:26 | 2 | 2
3 | 2008-09-12 09:11:25 | 1 | 2
3 | 2008-10-01 06:22:37 | 1 | 1
3 | 2008-10-20 01:55:51 | 2 | 1
3 | 2008-10-28 01:30:40 | 1 | 2
(12 rows)
```
# Fonction LAST window
À partir d'un ensemble ordonné de lignes, la fonction LAST renvoie la valeur de l'expression par rapport à la dernière ligne du cadre.
Pour savoir comment sélectionner la première ligne du cadre, consultez [Fonction de fenêtre FIRST](WF_FIRST.md).
## Syntaxe
```
LAST( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère.
IGNORE NULLS
La fonction renvoie la dernière valeur du cadre qui n’est pas NULL (ou NULL si toutes les valeurs sont NULL).
RESPECT NULLS
Indique que les valeurs nulles AWS Clean Rooms doivent être incluses dans la détermination de la ligne à utiliser. La clause RESPECT NULLS est prise en charge par défaut, si vous ne spécifiez pas IGNORE NULLS.
OVER
Présente les clauses de fenêtrage de la fonction.
PARTITION BY *expr\$1list*
Définit la fenêtre de la fonction en termes d’une ou de plusieurs expressions.
ORDER BY *order\$1list*
Trie les lignes dans chaque partition. Si aucune clause PARTITION BY n’est spécifiée, ORDER BY trie toute la table. Si vous spécifiez une clause ORDER BY, vous devez également spécifier une *frame\$1clause*.
Les résultats dépendent de l’ordre des données. Les résultats sont non déterministes dans les cas suivants :
+ Quand aucune clause ORDER BY n’est spécifiée et qu’une partition contient deux valeurs différentes pour une expression
+ Lorsque l’expression a des valeurs différentes qui correspondent à la même valeur dans la liste ORDER BY.
*frame\$1clause*
Si une clause ORDER BY est utilisée pour une fonction d’agrégation, une clause de cadre explicite est requise. La clause de cadre affine l’ensemble de lignes dans la fenêtre d’une fonction, en incluant ou en excluant des ensembles de lignes du résultat ordonné. La clause de cadre se compose du mot-clé ROWS et des spécificateurs associés. Consultez [Récapitulatif de la syntaxe de la fonction de fenêtrage](Window_functions.md#Window_function_synopsis).
## Type de retour
Ces fonctions prennent en charge les expressions qui utilisent des types de AWS Clean Rooms données primitifs. Le type de retour est identique au type de données de l’*expression*.
## Exemples
L’exemple suivant renvoie le nombre de places de chaque site dans la table VENUE, avec les résultats classés par capacité (d’élevée à faible). La fonction LAST permet de sélectionner le nom de la salle correspondant à la dernière ligne du cadre : dans ce cas, la rangée comportant le moins de places. Les résultats étant partitionnés par État, lorsque la valeur de VENUESTATE change, une nouvelle dernière valeur est sélectionnée. Comme le cadre de fenêtrage est illimité, la même dernière valeur est sélectionnée pour chaque ligne de chaque partition.
Pour la Californie, `Shoreline Amphitheatre` est renvoyé pour chaque ligne de la partition, car il possède le plus petit nombre de places (`22000`).
```
select venuestate, venueseats, venuename,
last(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | last
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Shoreline Amphitheatre
CA | 69843 | Monster Park | Shoreline Amphitheatre
CA | 63026 | McAfee Coliseum | Shoreline Amphitheatre
CA | 56000 | Dodger Stadium | Shoreline Amphitheatre
CA | 45050 | Angel Stadium of Anaheim | Shoreline Amphitheatre
CA | 42445 | PETCO Park | Shoreline Amphitheatre
CA | 41503 | AT&T Park | Shoreline Amphitheatre
CA | 22000 | Shoreline Amphitheatre | Shoreline Amphitheatre
CO | 76125 | INVESCO Field | Coors Field
CO | 50445 | Coors Field | Coors Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Tropicana Field
FL | 73800 | Jacksonville Municipal Stadium | Tropicana Field
FL | 65647 | Raymond James Stadium | Tropicana Field
FL | 36048 | Tropicana Field | Tropicana Field
...
```
# Fonction de fenêtrage LAST\$1VALUE
Pour un ensemble de lignes ordonnées, la fonction LAST\$1VALUE renvoie la valeur de l’expression par rapport à la dernière ligne du cadre.
Pour savoir comment sélectionner la première ligne du cadre, consultez [Fonction de fenêtrage FIRST\$1VALUE](WF_first_value.md).
## Syntaxe
```
LAST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## Arguments
*expression*
Colonne cible ou expression sur laquelle la fonction opère.
IGNORE NULLS
La fonction renvoie la dernière valeur du cadre qui n’est pas NULL (ou NULL si toutes les valeurs sont NULL).
RESPECT NULLS
Indique que les valeurs nulles AWS Clean Rooms doivent être incluses dans la détermination de la ligne à utiliser. La clause RESPECT NULLS est prise en charge par défaut, si vous ne spécifiez pas IGNORE NULLS.
OVER
Présente les clauses de fenêtrage de la fonction.
PARTITION BY *expr\$1list*
Définit la fenêtre de la fonction en termes d’une ou de plusieurs expressions.
ORDER BY *order\$1list*
Trie les lignes dans chaque partition. Si aucune clause PARTITION BY n’est spécifiée, ORDER BY trie toute la table. Si vous spécifiez une clause ORDER BY, vous devez également spécifier une *frame\$1clause*.
Les résultats dépendent de l’ordre des données. Les résultats sont non déterministes dans les cas suivants :
+ Quand aucune clause ORDER BY n’est spécifiée et qu’une partition contient deux valeurs différentes pour une expression
+ Lorsque l’expression a des valeurs différentes qui correspondent à la même valeur dans la liste ORDER BY.
*frame\$1clause*
Si une clause ORDER BY est utilisée pour une fonction d’agrégation, une clause de cadre explicite est requise. La clause de cadre affine l’ensemble de lignes dans la fenêtre d’une fonction, en incluant ou en excluant des ensembles de lignes du résultat ordonné. La clause de cadre se compose du mot-clé ROWS et des spécificateurs associés. Consultez [Récapitulatif de la syntaxe de la fonction de fenêtrage](Window_functions.md#Window_function_synopsis).
## Type de retour
Ces fonctions prennent en charge les expressions qui utilisent des types de AWS Clean Rooms données primitifs. Le type de retour est identique au type de données de l’*expression*.
## Exemples
L’exemple suivant renvoie le nombre de places de chaque site dans la table VENUE, avec les résultats classés par capacité (d’élevée à faible). La fonction LAST\$1VALUE permet de sélectionner le nom du lieu qui correspond à la dernière ligne du cadre : dans le cas présent, il s’agit de la ligne présentant le plus petit nombre de places. Les résultats étant partitionnés par État, lorsque la valeur de VENUESTATE change, une nouvelle dernière valeur est sélectionnée. Comme le cadre de fenêtrage est illimité, la même dernière valeur est sélectionnée pour chaque ligne de chaque partition.
Pour la Californie, `Shoreline Amphitheatre` est renvoyé pour chaque ligne de la partition, car il possède le plus petit nombre de places (`22000`).
```
select venuestate, venueseats, venuename,
last_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | last_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Shoreline Amphitheatre
CA | 69843 | Monster Park | Shoreline Amphitheatre
CA | 63026 | McAfee Coliseum | Shoreline Amphitheatre
CA | 56000 | Dodger Stadium | Shoreline Amphitheatre
CA | 45050 | Angel Stadium of Anaheim | Shoreline Amphitheatre
CA | 42445 | PETCO Park | Shoreline Amphitheatre
CA | 41503 | AT&T Park | Shoreline Amphitheatre
CA | 22000 | Shoreline Amphitheatre | Shoreline Amphitheatre
CO | 76125 | INVESCO Field | Coors Field
CO | 50445 | Coors Field | Coors Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Tropicana Field
FL | 73800 | Jacksonville Municipal Stadium | Tropicana Field
FL | 65647 | Raymond James Stadium | Tropicana Field
FL | 36048 | Tropicana Field | Tropicana Field
...
```
# Fonction de fenêtrage LEAD
La fonction de fenêtrage LEAD renvoie les valeurs pour une ligne avec un décalage donné au-dessous (après) de la ligne actuelle dans la partition.
## Syntaxe
```
LEAD (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## Arguments
*value\$1expr*
Colonne cible ou expression sur laquelle la fonction opère.
*offset*
Paramètre facultatif qui spécifie le nombre de lignes sous la ligne actuelle pour lesquelles renvoyer des valeurs. Le décalage peut être un nombre entier constant ou une expression qui a pour valeur un nombre entier. Si vous ne spécifiez pas de décalage, AWS Clean Rooms utilisez `1` comme valeur par défaut. Un décalage de `0` indique la ligne actuelle.
IGNORE NULLS
Spécification facultative qui indique que les valeurs nulles AWS Clean Rooms doivent être ignorées lors de la détermination de la ligne à utiliser. Les valeurs NULL sont incluses si IGNORE NULLS n’est pas répertorié.
Vous pouvez utiliser une expression NVL ou COALESCE pour remplacer les valeurs NULL par une autre valeur.
RESPECT NULLS
Indique que les valeurs nulles AWS Clean Rooms doivent être incluses dans la détermination de la ligne à utiliser. La clause RESPECT NULLS est prise en charge par défaut, si vous ne spécifiez pas IGNORE NULLS.
OVER
Spécifie le partitionnement de fenêtrage et d’ordonnancement. La clause OVER ne peut pas contenir de spécification de cadre de fenêtrage.
PARTITION BY *window\$1partition*
Argument facultatif qui définit la plage d’enregistrements de chaque groupe de la clause OVER.
ORDER BY *window\$1ordering*
Trie les lignes dans chaque partition.
La fonction de fenêtre LEAD prend en charge les expressions qui utilisent n'importe quel type de AWS Clean Rooms données. Le type de retour est identique au type *value\$1expr*.
## Exemples
L’exemple suivant fournit la commission pour les événements de la table SALES pour les billets ont été vendus sur le 1er janvier 2008 et le 2 janvier 2008 et la commission payée pour la vente des billets de la vente suivante.
```
select eventid, commission, saletime,
lead(commission, 1) over (order by saletime) as next_comm
from sales where saletime between '2008-01-01 00:00:00' and '2008-01-02 12:59:59'
order by saletime;
eventid | commission | saletime | next_comm
---------+------------+---------------------+-----------
6213 | 52.05 | 2008-01-01 01:00:19 | 106.20
7003 | 106.20 | 2008-01-01 02:30:52 | 103.20
8762 | 103.20 | 2008-01-01 03:50:02 | 70.80
1150 | 70.80 | 2008-01-01 06:06:57 | 50.55
1749 | 50.55 | 2008-01-01 07:05:02 | 125.40
8649 | 125.40 | 2008-01-01 07:26:20 | 35.10
2903 | 35.10 | 2008-01-01 09:41:06 | 259.50
6605 | 259.50 | 2008-01-01 12:50:55 | 628.80
6870 | 628.80 | 2008-01-01 12:59:34 | 74.10
6977 | 74.10 | 2008-01-02 01:11:16 | 13.50
4650 | 13.50 | 2008-01-02 01:40:59 | 26.55
4515 | 26.55 | 2008-01-02 01:52:35 | 22.80
5465 | 22.80 | 2008-01-02 02:28:01 | 45.60
5465 | 45.60 | 2008-01-02 02:28:02 | 53.10
7003 | 53.10 | 2008-01-02 02:31:12 | 70.35
4124 | 70.35 | 2008-01-02 03:12:50 | 36.15
1673 | 36.15 | 2008-01-02 03:15:00 | 1300.80
...
(39 rows)
```
# Fonction de fenêtrage PERCENT\$1RANK
Calcule le rang en pourcentage d’une ligne donnée. Le rang en pourcentage est déterminé à l’aide de la formule suivante :
`(x - 1) / (the number of rows in the window or partition - 1)`
où *x* est le rang de la ligne actuelle. Le jeu de données suivant illustre l’utilisation de cette formule :
```
Row# Value Rank Calculation PERCENT_RANK
1 15 1 (1-1)/(7-1) 0.0000
2 20 2 (2-1)/(7-1) 0.1666
3 20 2 (2-1)/(7-1) 0.1666
4 20 2 (2-1)/(7-1) 0.1666
5 30 5 (5-1)/(7-1) 0.6666
6 30 5 (5-1)/(7-1) 0.6666
7 40 7 (7-1)/(7-1) 1.0000
```
La plage de valeur de retour est comprise entre 0 et 1, inclus. La première ligne de n’importe quel jeu dispose d’une fonction PERCENT\$1RANK spécifiée sur 0.
## Syntaxe
```
PERCENT_RANK ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## Arguments
( )
La fonction ne prend pas d’arguments, mais les parenthèses vides sont obligatoires.
OVER
Clause qui spécifie le partitionnement de fenêtrage. La clause OVER ne peut pas contenir de spécification de cadre de fenêtrage.
PARTITION BY *partition\$1expression*
Facultatif. Expression qui définit la plage d’enregistrements de chaque groupe dans la clause OVER.
ORDER BY *order\$1list*
Facultatif. Expression permettant de calculer le rang en pourcentage. L’expression doit disposer d’un type de données numériques ou être convertible implicitement en une. Si ORDER BY n’est pas spécifié, la valeur de retour est 0 pour toutes les lignes.
Si ORDER BY ne génère pas d’ordonnancement unique, l’ordre des lignes est non déterministe. Pour de plus amples informations, veuillez consulter [Ordonnancement unique des données pour les fonctions de fenêtrage](Window_functions.md#Examples_order_by_WF).
## Type de retour
FLOAT8
## Exemples
L’exemple suivant calcule le rang en pourcentage des volumes de ventes de chaque vendeur :
```
select sellerid, qty, percent_rank()
over (partition by sellerid order by qty)
from winsales;
sellerid qty percent_rank
----------------------------------------
1 10.00 0.0
1 10.64 0.5
1 30.37 1.0
3 10.04 0.0
3 15.15 0.33
3 20.75 0.67
3 30.55 1.0
2 20.09 0.0
2 20.12 1.0
4 10.12 0.0
4 40.23 1.0
```
Pour obtenir une description de la table WINSALES, consultez [Exemple de tableau contenant des exemples de fonctions de fenêtrage](Window_functions.md#Window_function_example).
# Fonction de fenêtrage RANK
La fonction de fenêtrage RANK détermine le rang d’une valeur dans un groupe de valeurs, en fonction de l’expression ORDER BY dans la clause OVER. Si la clause PARTITION BY facultative est présente, les rangs sont réinitialisés pour chaque groupe de lignes. Les lignes présentant des valeurs égales pour les critères de classement reçoivent le même classement. AWS Clean Roomsajoute le nombre de lignes égales au rang égal pour calculer le rang suivant. Les rangs peuvent donc ne pas être des nombres consécutifs. Par exemple, si deux lignes sont classées 1, le prochain rang est 3.
La fonction RANK diffère de [Fonction de fenêtrage DENSE\$1RANK](WF_DENSE_RANK.md) sur un point : pour DENSE\$1RANK, si deux lignes ou plus sont à égalité, il n’y a aucun écart dans la séquence des valeurs classées. Par exemple, si deux lignes sont classées 1, le prochain rang est 2.
Vous pouvez avoir des fonctions de rang avec différentes clauses PARTITION BY et ORDER BY dans la même requête.
## Syntaxe
```
RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Arguments
( )
La fonction ne prend pas d’arguments, mais les parenthèses vides sont obligatoires.
OVER
Clauses de fenêtrage de la fonction RANK.
PARTITION BY *expr\$1list*
Facultatif. Une ou plusieurs expressions qui définissent le fenêtrage.
ORDER BY *order\$1list*
Facultatif. Définit les colonnes sur lesquelles les valeurs de rang sont basées. Si aucune clause PARTITION BY n’est spécifiée, ORDER BY utilise toute la table. Si ORDER BY n’est pas spécifié, la valeur de retour est 1 pour toutes les lignes.
Si ORDER BY ne génère pas d’ordonnancement unique, l’ordre des lignes est non déterministe. Pour de plus amples informations, veuillez consulter [Ordonnancement unique des données pour les fonctions de fenêtrage](Window_functions.md#Examples_order_by_WF).
## Type de retour
INTEGER
## Exemples
L’exemple suivant montre le classement de la table selon la quantité vendue (croissant par défaut) et l’affectation d’un rang à chaque ligne. 1 est la valeur classée la plus élevée. Les résultats sont triés une fois que les résultats de la fonction de fenêtrage sont appliqués:
```
select salesid, qty,
rank() over (order by qty) as rnk
from winsales
order by 2,1;
salesid | qty | rnk
--------+-----+-----
10001 | 10 | 1
10006 | 10 | 1
30001 | 10 | 1
40005 | 10 | 1
30003 | 15 | 5
20001 | 20 | 6
20002 | 20 | 6
30004 | 20 | 6
10005 | 30 | 9
30007 | 30 | 9
40001 | 40 | 11
(11 rows)
```
Notez que la clause externe ORDER BY de cet exemple inclut les colonnes 2 et 1 pour garantir que les résultats AWS Clean Rooms sont systématiquement triés chaque fois que cette requête est exécutée. Par exemple, les lignes avec les ventes IDs 10001 et 10006 ont des valeurs QTY et RNK identiques. L’ordonnancement du résultat final défini par la colonne 1 garantit que la ligne 10001 précède toujours 10006. Pour obtenir une description de la table WINSALES, consultez [Exemple de tableau contenant des exemples de fonctions de fenêtrage](Window_functions.md#Window_function_example).
Dans l’exemple suivant, l’ordonnancement est inversé pour la fonction de fenêtrage (`order by qty desc`). A présent, la valeur de rang la plus élevée s’applique à la valeur QTY la plus élevée.
```
select salesid, qty,
rank() over (order by qty desc) as rank
from winsales
order by 2,1;
salesid | qty | rank
---------+-----+-----
10001 | 10 | 8
10006 | 10 | 8
30001 | 10 | 8
40005 | 10 | 8
30003 | 15 | 7
20001 | 20 | 4
20002 | 20 | 4
30004 | 20 | 4
10005 | 30 | 2
30007 | 30 | 2
40001 | 40 | 1
(11 rows)
```
Pour obtenir une description de la table WINSALES, consultez [Exemple de tableau contenant des exemples de fonctions de fenêtrage](Window_functions.md#Window_function_example).
L’exemple suivant montre le partitionnement de la table en fonction de chaque SELLERID, le classement de chaque partition selon la quantité (par ordre décroissant) et l’affectation d’un rang à chaque ligne. Les résultats sont triés une fois que les résultats de la fonction de fenêtrage sont appliqués.
```
select salesid, sellerid, qty, rank() over
(partition by sellerid
order by qty desc) as rank
from winsales
order by 2,3,1;
salesid | sellerid | qty | rank
--------+----------+-----+-----
10001 | 1 | 10 | 2
10006 | 1 | 10 | 2
10005 | 1 | 30 | 1
20001 | 2 | 20 | 1
20002 | 2 | 20 | 1
30001 | 3 | 10 | 4
30003 | 3 | 15 | 3
30004 | 3 | 20 | 2
30007 | 3 | 30 | 1
40005 | 4 | 10 | 2
40001 | 4 | 40 | 1
(11 rows)
```
# Fonction de fenêtrage ROW\$1NUMBER
Détermine le nombre ordinal de la ligne actuelle au sein d'un groupe de lignes, à partir de 1, en fonction de l'expression ORDER BY de la clause OVER. Si la clause PARTITION BY facultative est présente, les nombres ordinaux sont réinitialisés pour chaque groupe de lignes. Les lignes avec des valeurs égales pour les expressions ORDER BY reçoivent des numéros de lignes différentes de manière non déterministe.
## Syntaxe
```
ROW_NUMBER () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## Arguments
( )
La fonction ne prend pas d’arguments, mais les parenthèses vides sont obligatoires.
OVER
Clauses de fenêtrage pour la fonction ROW\$1NUMBER.
PARTITION BY *expr\$1list*
Facultatif. Une ou plusieurs expressions qui définissent la fonction ROW\$1NUMBER.
ORDER BY *order\$1list*
Facultatif. Expression qui définit les colonnes sur lesquelles sont basées les numéros de lignes. Si aucune clause PARTITION BY n’est spécifiée, ORDER BY utilise toute la table.
Si ORDER BY ne génère pas d’ordonnancement unique ou n’est pas spécifiée, l’ordre des lignes est non déterministe. Pour de plus amples informations, veuillez consulter [Ordonnancement unique des données pour les fonctions de fenêtrage](Window_functions.md#Examples_order_by_WF).
## Type de retour
BIGINT
## Exemples
L’exemple suivant présente la partition de la table par SELLERID et classe chaque partition par QTY (en ordre croissant), puis affecte un numéro de ligne à chaque ligne. Les résultats sont triés une fois que les résultats de la fonction de fenêtrage sont appliqués.
```
select salesid, sellerid, qty,
row_number() over
(partition by sellerid
order by qty asc) as row
from winsales
order by 2,4;
salesid | sellerid | qty | row
---------+----------+-----+-----
10006 | 1 | 10 | 1
10001 | 1 | 10 | 2
10005 | 1 | 30 | 3
20001 | 2 | 20 | 1
20002 | 2 | 20 | 2
30001 | 3 | 10 | 1
30003 | 3 | 15 | 2
30004 | 3 | 20 | 3
30007 | 3 | 30 | 4
40005 | 4 | 10 | 1
40001 | 4 | 40 | 2
(11 rows)
```
Pour obtenir une description de la table WINSALES, consultez [Exemple de tableau contenant des exemples de fonctions de fenêtrage](Window_functions.md#Window_function_example).