Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Fonctions 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).