Comment classer les rangs en SQL : un guide complet.

Ne vous débattez plus avec les fonctions de classement SQL ! Cet article vous guidera à travers les cas d'utilisation de classement les plus courants.

Les classements sont utilisés autour de nous, tous les jours. Les tournois sportifs, les meilleurs films et séries télévisées sur Netflix, les magasins proposant les produits les moins chers : ce ne sont là que quelques exemples de classements que vous avez pu voir récemment.

L'utilisation des fonctions SQL RANK peut parfois être difficile. La variété des constructions différentes est énorme. Vous pouvez facilement vous perdre dans tout ce qu'il y a à apprendre à propos du classement. L'essentiel est de comprendre les concepts importants et de savoir où chercher des informations supplémentaires.

Vous trouverez dans ce guide les connaissances qui vous permettront d'écrire de nombreux types de requêtes de classement SQL. Tout d'abord, je vais expliquer comment fonctionne le classement. Je vous montrerai ensuite un certain nombre d'exemples. Si vous recherchez des cas d'utilisation spécifiques, vous pouvez simplement vous plonger dans la section Cas d'utilisation du classement SQL.

Les fonctions de classement SQL sont des fonctions de fenêtrage.

Commençons par les bases. Que sont exactement les fonctions de classement en SQL ? Elles font partie d'une famille de fonctions appelées fonctions de fenêtre. Les fonctions à fenêtre utilisent un champ d'application (une fenêtre), qui examine une partie des données pour calculer le résultat. Ensuite, elle se déplace vers une autre partie des données et calcule le résultat pour cette portion. Vous pouvez avoir une idée de base de son fonctionnement en consultant l'exemple de fonction fenêtre SQL avec explications.

Bien qu'il existe un grand nombre de fonctions de fenêtre différentes, je me concentrerai uniquement sur le classement. Je n'expliquerai pas non plus en détail le fonctionnement interne des fonctions de fenêtre. Cet article se concentrera sur les fonctions de classement SQL et sur la manière de les utiliser dans différentes situations. Pour en savoir plus sur les fonctions de fenêtre, consultez ce cours Fonctions de fenêtrage.

Fonctions de classement de base.

Les types de fonctions de classement les plus courants (et les plus simples) sont les suivants :

• RANK()
• DENSE_RANK()
• ROW_NUMBER()

Que font-elles et en quoi sont-elles différentes les unes des autres ? Je vais expliquer brièvement chacune d'entre elles. Je comparerai ensuite les classements pour chacune des fonctions.

La fonction RANK() crée un classement des lignes en fonction d'une colonne donnée. Elle commence par attribuer la valeur "1" à la première ligne de l'ordre, puis attribue des chiffres plus élevés aux lignes situées plus bas dans l'ordre. Si les lignes ont la même valeur, elles sont classées de la même façon. Toutefois, la place suivante est décalée en conséquence. Par exemple, si deux lignes sont au 5e rang (ont le même rang), la ligne suivante sera au 7e rang (c'est-à-dire que le 6e rang n'existe pas).

La fonction DENSE_RANK() est assez similaire. La seule différence est qu'elle ne laisse pas de vide dans le classement. Même si plusieurs lignes peuvent avoir le même rang, la ligne suivante obtiendra le rang suivant. Par exemple, si deux rangs sont 5èmes, le rang suivant sera 6ème.

La fonction ROW_NUMBER() est différente. Si des lignes ont la même valeur, elles obtiendront toutes des rangs consécutifs (pas le même rang qu'avec les fonctions précédentes). Par exemple, si deux lignes ont la même valeur (elles seraient toutes deux 5èmes avec les fonctions précédentes), ROW_NUMBER() les placera en 5ème et 6ème position.

Vous pouvez maintenant vous demander : Si plusieurs lignes ont la même valeur et que nous utilisons ROW_NUMBER(), comment pouvons-nous savoir quelle ligne sera la première, la deuxième, etc. La réponse est plutôt sombre : nous ne le pouvons pas ! Cela dépend de nombreux facteurs, et vous ne pouvez pas prédire quelle ligne obtiendra quel rang.

Ce sont les fonctions de classement SQL de base et (probablement) les plus utilisées. Si vous souhaitez en savoir plus sur d'autres fonctions de classement, vous pouvez lire cet aperçu des fonctions de classement.

RANK() vs. DENSE_RANK() vs. ROW_NUMBER()

Maintenant que vous connaissez la théorie des fonctions de classement, comparons les résultats de ces fonctions. Pour ce faire, nous allons classer certaines personnes en fonction de leurs résultats aux examens. Examinez les données suivantes (table exam_result) :

first_name	last_name	points
Emyr	Downes	70
Dina	Morin	70
Evie-May	Boyer	80
Nora	Parkinson	60
Trystan	Oconnor	40
Eryk	Myers	90
Marlene	Duncan	90
Marius	Powell	90
Joanne	Goddard	50
Rayhan	Williamson	90

Nous allons créer une requête qui classe les lignes par la colonne des points en utilisant les fonctions de classement décrites ci-dessus :

SELECT
  RANK() OVER(ORDER BY points DESC) AS rank,
  DENSE_RANK() OVER(ORDER BY points DESC) AS dense_rank,
  ROW_NUMBER() OVER(ORDER BY points DESC) AS row_number,
  first_name,
  last_name,
  points
FROM exam_result;

Analysons le code avant de l'exécuter pour voir les résultats. La première colonne que nous voulons afficher est rank. Il s'agit simplement du classement créé à l'aide de la fonction RANK(). Cependant, que signifie OVER(ORDER BY points DESC)? Cela fait partie du concept de fonction fenêtre. OVER() est un élément obligatoire de toutes les fonctions de classement (en fait, de toutes les fonctions fenêtre). Elle indique à la fonction l'étendue des données (fenêtre) et l'ordre dans lequel les lignes seront placées. Dans ce cas, nous n'avons fourni que l'ordre. Vous trouverez un exemple de définition d'une fenêtre dans la section RANK() OVER(PARTITION BY ...)-Single Column.

Puisque vous comprenez maintenant la première colonne, vous devriez également comprendre les deux suivantes. La seule différence est le nom des fonctions de classement. En outre, les trois dernières colonnes devraient être explicites, puisque vous avez déjà vu les données.

Très bien, regardons les résultats :

rank	dense_rank	row_number	first_name	last_name	points
1	1	1	Marlene	Duncan	90
1	1	2	Rayhan	Williamson	90
1	1	3	Marius	Powell	90
1	1	4	Eryk	Myers	90
5	2	5	Evie-May	Boyer	80
6	3	6	Emyr	Downes	70
6	3	7	Dina	Morin	70
8	4	8	Nora	Parkinson	60
9	5	9	Joanne	Goddard	50
10	6	10	Trystan	Oconnor	40

Pouvez-vous repérer les différences entre chaque fonction ? Pour les premières lignes, les colonnes rank et dense_rank sont identiques. Cependant, row_number semble différent dès le début. Même si Marlene, Rayhan, Marius et Eryk ont le même nombre de points, la fonction ROW_NUMBER() leur a attribué des valeurs distinctes. Comme mentionné précédemment, l'ordre dans lequel ces personnes ont obtenu leur rang n'est pas déterministe.

Il est intéressant de noter que vous pouvez rendre le résultat de ROW_NUMBER() plus déterministe. Il suffit d'ajouter des colonnes supplémentaires à l'ordre (par exemple, ROW_NUMBER() OVER (ORDER BY points DESC, last_name ASC)). Ceci sera expliqué plus en détail dans la section Rang sur plusieurs colonnes.

Vous pouvez également rendre ROW_NUMBER() encore moins déterministe ! Même si la partie ORDER BY est nécessaire pour RANK() et DENSE_RANK(), ROW_NUMBER() ne l'exige pas du tout. C'est ainsi que vous pouvez numéroter les lignes sans ordre spécifique.

Une autre différence peut être observée plus bas dans le tableau. Evie-May est classée 5e par la fonction RANK() et 2e par la fonction DENSE_RANK(). La première fonction note combien de lignes ont le même classement et la ligne suivante est classée en conséquence. La seconde fonction prend simplement en compte la valeur précédente et la ligne suivante est classée en conséquence.

Prenez le temps d'examiner les classements ci-dessus et assurez-vous de bien comprendre la différence entre ces trois fonctions de classement SQL. Il est important de savoir quelle fonction utiliser dans quels cas. Si vous avez besoin de plus d'explications, consultez la rubrique Comment utiliser les fonctions de classement en SQL.

Cas d'utilisation du classement SQL.

Il est temps de nous plonger dans quelques requêtes SQL RANK. Nous allons commencer par des requêtes simples et augmenter progressivement la complexité. Le plan est le suivant :

• Classement de base :
  • Classement sur une seule colonne
  • Classement sur plusieurs colonnes
  • RANK() avec les 10 premiers résultats
• Classement avec des dates :
  • Classement par date
  • Classement par mois
• Classement avec des fonctions agrégées :
  • Classement avec GROUP BY
  • Classement avec COUNT()
  • Classement avec SUM()
• Utilisation de la partition par :
  • RANK() SUR(PARTITION BY ...)-Simple colonne
  • RANK() OVER(PARTITION BY ...)-Multiples colonnes

Notez que même si nous utilisons principalement la fonction SQL RANK(), les exemples peuvent être appliqués à DENSE_RANK() et ROW_NUMBER(). Cela dépend de vos besoins. Il est donc important de comprendre les différences entre ces fonctions.

Dans les exemples, nous allons utiliser les données modifiées de l'exemple précédent. La colonne exam_date indique quand la personne a passé l'examen, et la colonne city indique dans quelle ville la personne a passé l'examen. Jetez-y un coup d'œil :

first_name	last_name	exam_date	city	points
Emyr	Downes	2018-12-18	San Francisco	70
Dina	Morin	2019-01-17	Los Angeles	70
Evie-May	Boyer	2019-01-23	San Francisco	80
Nora	Parkinson	2019-02-16	San Diego	60
Trystan	Oconnor	2019-02-28	Los Angeles	40
Eryk	Myers	2019-06-07	San Francisco	90
Marlene	Duncan	2019-06-13	San Diego	90
Marius	Powell	2019-11-13	San Diego	90
Joanne	Goddard	2019-12-18	San Diego	50
Marius	Williamson	2020-01-02	San Diego	90

Classement sur une seule colonne.

Nous allons commencer par le cas d'utilisation le plus simple : créer un classement basé sur une seule colonne. Nous allons baser notre classement sur les points :

SELECT
  RANK() OVER(ORDER BY points DESC) AS ranking,
  first_name,
  last_name,
  points
FROM exam_result;

La requête est assez simple, comme l'exemple précédent. Elle crée un classement basé sur le nombre de points par ordre décroissant. Nous utilisons RANK() OVER(ORDER BY ...) pour indiquer quelle colonne doit être utilisée pour le classement. Les résultats ressemblent à ceci :

ranking	first_name	last_name	points
1	Marlene	Duncan	90
1	Marius	Williamson	90
1	Marius	Powell	90
1	Eryk	Myers	90
5	Evie-May	Boyer	80
6	Emyr	Downes	70
6	Dina	Morin	70
8	Nora	Parkinson	60
9	Joanne	Goddard	50
10	Trystan	Oconnor	40

Si vous souhaitez créer un classement basé sur une colonne différente ou dans un ordre différent (par exemple, croissant au lieu de décroissant), il suffit de changer le nom de la colonne ou de remplacer le mot-clé DESC par le mot-clé ASC.

Classement sur plusieurs colonnes

L'utilisation de plusieurs colonnes pour le classement est également simple. Il suffit d'ajouter le nom de la colonne suivante après la virgule. Si les valeurs de la première colonne sont égales, alors la deuxième colonne est prise en considération, et ainsi de suite. Regardez :

SELECT
  RANK() OVER(ORDER BY points DESC, first_name ASC) AS ranking,
  first_name,
  last_name,
  points
FROM exam_result;

Cette requête est similaire à la précédente. Nous avons ajouté first_name ASC à la clause d'ordre. De cette façon, si plusieurs lignes ont la même valeur dans la première colonne, la deuxième est prise en considération. Notez que si la deuxième colonne est identique, le classement est résolu sur la base de la fonction que nous utilisons (dans notre cas RANK()). Jetez un coup d'œil au résultat :

ranking	first_name	last_name	points
1	Eryk	Myers	90
2	Marius	Williamson	90
2	Marius	Powell	90
4	Marlene	Duncan	90
5	Evie-May	Boyer	80
6	Dina	Morin	70
7	Emyr	Downes	70
8	Nora	Parkinson	60
9	Joanne	Goddard	50
10	Trystan	Oconnor	40

Comme vous pouvez le constater, les personnes ayant le même nombre de points obtiennent des classements différents parce qu'elles ont des noms différents. Les seules exceptions sont les deux personnes qui s'appellent Marius. Comme elles ont le même nom et le même nombre de points, elles ont le même rang.

Il convient de mentionner que le classement par quelques colonnes peut être utile si vous souhaitez que le résultat de la fonction ROW_NUMBER() soit déterministe. Jetez un coup d'œil à cette requête :

SELECT
  ROW_NUMBER() OVER(ORDER BY points DESC, last_name ASC) AS ranking,
  first_name,
  last_name,
  points
FROM exam_result;

Puisque chaque personne dans nos données a un nom de famille différent, nous pouvons l'ajouter à la clause de classement afin de pouvoir prédire qui obtient quel rang. Regardez :

ranking	first_name	last_name	points
1	Marlene	Duncan	90
2	Eryk	Myers	90
3	Marius	Powell	90
4	Marius	Williamson	90
5	Evie-May	Boyer	80
6	Emyr	Downes	70
7	Dina	Morin	70
8	Nora	Parkinson	60
9	Joanne	Goddard	50
10	Trystan	Oconnor	40

Dans ce cas, la fonction ROW_NUMBER() fonctionne comme RANK() et DENSE_RANK() car chaque rang peut être placé de manière déterministe. Notez cependant que si plusieurs personnes avaient le même nom de famille, la fonction ROW_NUMBER() ne serait pas déterministe, même si le classement est effectué sur deux colonnes.

RANK() avec les 10 premiers résultats.

Nous créons souvent des classements pour afficher les meilleurs résultats (par exemple, les 10 premiers, les 100 premiers, etc.). Comme vous pouvez vous y attendre, vous pouvez afficher les meilleurs résultats à l'aide des fonctions de classement SQL. Une telle requête est cependant un peu plus compliquée. Jetez-y un coup d'œil :

SELECT
  *
FROM (
  SELECT
    RANK() OVER(ORDER BY points DESC) AS ranking,
    first_name,
    last_name,
    points
  FROM exam_result
) AS a
WHERE ranking <= 3;

Dans cette requête, nous utilisons une sous-requête pour calculer le classement, puis, dans la requête principale, nous filtrons les résultats afin que seuls les trois premiers soient affichés. Les résultats pourraient vous surprendre :

ranking	first_name	last_name	points
1	Marlene	Duncan	90
1	Marius	Williamson	90
1	Marius	Powell	90
1	Eryk	Myers	90

Comme vous pouvez le voir, les résultats présentent quatre lignes, et chacune d'entre elles a la même valeur dans la colonne de classement. C'est à cause de nos données. Quatre lignes ont le même nombre de points et obtiennent donc le même rang dans la sous-requête.

Pour écrire une telle requête vous-même, placez votre requête de classement dans une sous-requête, et effectuez un filtrage autour d'elle. Par exemple, pour afficher les 10, changez WHERE ranking <= 3 en WHERE ranking <= 10.

Il est également intéressant de noter ce qui se passe lorsque vous utilisez DENSE_RANK() avec ces données. Jetez un coup d'œil à la requête ci-dessous et à ses résultats :

SELECT
  *
FROM (
  SELECT
    DENSE_RANK() OVER(ORDER BY points DESC) AS ranking,
    first_name,
    last_name,
    points
  FROM exam_result
) AS a
WHERE ranking <= 3;

ranking	first_name	last_name	points
1	Marlene	Duncan	90
1	Marius	Williamson	90
1	Marius	Powell	90
1	Eryk	Myers	90
2	Evie-May	Boyer	80
3	Emyr	Downes	70
3	Dina	Morin	70

Comme vous pouvez le voir, il y a beaucoup de lignes dans le résultat ! Une fois de plus, cela est dû à la façon dont DENSE_RANK() classe chaque ligne. Cet exemple montre clairement qu'il est important de comprendre la différence entre chaque fonction et de savoir laquelle utiliser dans une situation donnée.

Classement par date.

SELECT
  RANK() OVER(ORDER BY exam_date ASC) AS ranking,
  first_name,
  last_name,
  exam_date
FROM exam_result;

Dans ce cas, nous utilisons simplement la colonne exam_date pour le classement. Il y a très peu de différence entre le classement par date et par toute autre colonne. Jetez un coup d'œil aux résultats :

ranking	first_name	last_name	exam_date
1	Emyr	Downes	2018-12-18
2	Dina	Morin	2019-01-17
3	Evie-May	Boyer	2019-01-23
4	Nora	Parkinson	2019-02-16
5	Trystan	Oconnor	2019-02-28
6	Eryk	Myers	2019-06-07
7	Marlene	Duncan	2019-06-13
8	Marius	Powell	2019-11-13
9	Joanne	Goddard	2019-12-18
10	Marius	Williamson	2020-01-02

La chose importante à retenir est que ASC (ascendant) dans le cas des dates signifie que la plus ancienne sera placée en premier. Dans l'ordre DESC (décroissant), la date la plus récente sera placée en premier.

Classement par mois.

Vous pouvez également souhaiter classer les lignes en utilisant uniquement une partie de la date (par exemple, le mois). Ce n'est pas très difficile si vous connaissez les fonctions de date. Jetez un coup d'œil à la requête suivante :

SELECT
  RANK() OVER(ORDER BY EXTRACT('year' FROM exam_date) ASC,
    EXTRACT('month' FROM exam_date) ASC) AS ranking,
  first_name,
  last_name,
  exam_date
FROM exam_result;

Nous utilisons la fonction EXTRACT() pour extraire une certaine partie de la date. Nous voulons tout d'abord ordonner les lignes par année, puis par mois. Nous utilisons donc d'abord EXTRACT('year' FROM exam_date), puis EXTRACT('month' FROM exam_date). Regardez les résultats :

ranking	first_name	last_name	exam_date
1	Emyr	Downes	2018-12-18
2	Evie-May	Boyer	2019-01-23
2	Dina	Morin	2019-01-17
4	Nora	Parkinson	2019-02-16
4	Trystan	Oconnor	2019-02-28
6	Marlene	Duncan	2019-06-13
6	Eryk	Myers	2019-06-07
8	Marius	Powell	2019-11-13
9	Joanne	Goddard	2019-12-18
10	Marius	Williamson	2020-01-02

EXTRACT()

est une fonction assez simple. Vous lui dites quelle partie de la date vous voulez extraire de la date. Il existe un grand nombre de parties de date différentes que vous pouvez utiliser. Il est préférable de consulter la documentation de votre système de gestion de base de données (SGBD). Les parties les plus courantes sont :

• 'year'
• 'month'
• 'day'
• 'hour'
• 'minute'
• 'second'

Il convient également de mentionner que tous les SGBD ne prennent pas en charge cette fonction. Ceux qui le font sont PostgreSQL et MySQL. Dans SQL Server, cette fonction est appelée DATEPART().

Les opérations sur la date et l'heure sont un sujet assez difficile, qui dépasse le cadre de cet article. Si vous souhaitez en savoir plus sur la fonction EXTRACT() et bien d'autres, consultez le cours Fonctions SQL standards. Il comporte une section entière consacrée aux opérations sur la date et l'heure.

Classement avec GROUP BY.

Nous allons maintenant voir comment utiliser les classements avec les fonctions d'agrégation. Même si cela semble effrayant, il s'agit d'un concept assez logique si l'on comprend bien. Votre base de données calcule d'abord les fonctions d'agrégation, puis crée un classement sur la base des valeurs calculées. Jetez un coup d'œil à cet exemple avec AVG() :

SELECT
  RANK() OVER(ORDER BY AVG(points) DESC) AS ranking,
  city,
  AVG(points) AS average_points
FROM exam_result
GROUP BY city;

Comme vous pouvez le constater, cette requête n'est pas très différente des autres requêtes que nous avons vues jusqu'à présent. Vous pouvez simplement utiliser des fonctions d'agrégation à l'intérieur de fonctions de classement. La chose importante à retenir est d'utiliser la clause GROUP BY. Comme nous l'avons mentionné plus haut, les fonctions d'agrégation sont calculées en premier. Cela signifie qu'avec GROUP BY, vous ne pouvez utiliser que des fonctions d'agrégation ou les expressions que vous regroupez dans la fonction de classement.

Par exemple, si vous souhaitez utiliser une autre colonne pour le classement afin que les lignes soient classées par cette autre colonne si le nombre moyen de points est le même, vous devez inclure cette autre colonne dans la clause GROUP BY.

La requête ci-dessus renvoie le nombre moyen de points marqués par les habitants de chaque ville.

ranking	city	average_points
1	San Francisco	80
2	San Diego	76
3	Los Angeles	55

Classement avec COUNT().

Maintenant, nous allons examiner une fonction d'agrégation souvent utilisée - COUNT():

SELECT
  RANK() OVER(ORDER BY COUNT(*) DESC) AS ranking,
  city,
  COUNT(*) AS exam_takers
FROM exam_result
GROUP BY city;

Comme vous pouvez le constater, cette requête n'est pas très différente de la précédente. Toutes les fonctions d'agrégation sont utilisées de la même manière avec les fonctions de classement.

Les résultats sont les suivants :

ranking	city	exam_takers
1	San Diego	5
2	San Francisco	3
3	Los Angeles	2

La requête calcule le nombre de personnes ayant passé l'examen dans chaque ville et crée ensuite un classement basé sur cette valeur.

Classement avec SUM().

Une autre fonction d'agrégation populaire est SUM(). Elle est également assez simple à utiliser :

SELECT
  RANK() OVER(ORDER BY SUM(points) DESC) AS ranking,
  city,
  SUM(points) AS total_points
FROM exam_result
GROUP BY city;

Une fois encore, nous utilisons simplement la fonction SUM() avec la fonction SQL RANK().

ranking	city	total_points
1	San Diego	380
2	San Francisco	240
3	Los Angeles	110

Nous avons calculé cette fois le nombre total de points acquis par les personnes de chaque ville.

RANK() OVER(PARTITION BY ...) - Colonne simple.

J'espère que vous êtes prêt à aborder un concept de classement plus avancé : PARTITION BY. Il vous permet de créer des classements dans des groupes distincts. Jetez un coup d'œil à cette requête :

SELECT
  RANK() OVER(PARTITION BY city ORDER BY points DESC) AS ranking,
  city,
  first_name,
  last_name,
  points
FROM exam_result;

Dans cette requête, nous utilisons PARTITION BY avec une seule colonne pour créer un classement des personnes dans chaque ville. De cette façon, nous pouvons voir les personnes ayant les meilleurs résultats dans chaque ville. Jetez un coup d'œil aux résultats :

ranking	city	first_name	last_name	points
1	San Francisco	Eryk	Myers	90
2	San Francisco	Evie-May	Boyer	80
3	San Francisco	Emyr	Dowes	70
1	Los Angeles	Dina	Morin	70
2	Los Angeles	Trystan	Oconnor	40
1	San Diego	Marlene	Duncan	90
1	San Diego	Marius	Powell	90
1	San Diego	Marius	Williamson	90
4	San Diego	Nora	Parkinson	60
5	San Diego	Joanne	Goddard	50

Comme vous pouvez le voir, les classements sont calculés séparément pour chaque ville. Ainsi, Eryk et Dina ont le même classement, même s'ils ont obtenu des notes différentes. De même, Dina et Emyr ont les mêmes résultats, mais Dina est mieux classée car elle a passé l'examen dans une autre ville.

Dans certains cas, le concept de PARTITION BY est important et il est donc utile de le rappeler. La bonne nouvelle, c'est qu'il est également assez simple à utiliser. Cependant, si vous voulez plus d'informations, vous pouvez lire Common SQL Fonctions de fenêtrage: Using Partitions With Ranking Functions sur le blog LearnSQL.com

.

RANK() OVER(PARTITION BY ...) - Colonnes multiples.

Examinons enfin la clause PARTITION BY avec plusieurs colonnes. Ce n'est pas très différent de l'utilisation de PARTITION BY avec une seule colonne. Jetez-y un coup d'œil :

SELECT
  RANK() OVER(PARTITION BY city, first_name
    ORDER BY exam_date ASC) AS ranking,
  city,
  first_name,
  last_name,
  exam_date
FROM exam_result;

Dans la requête ci-dessus, nous utilisons PARTITION BY avec deux colonnes : city et first_name. Cela signifie que pour chaque paire distincte de ville et de prénom, nous aurons des classements séparés. Jetez un coup d'œil aux résultats :

ranking	city	first_name	last_name	exam_date
1	San Francisco	Eryk	Myers	2019-06-07
1	San Francisco	Evie-May	Boyer	2019-01-23
1	San Francisco	Emyr	Dowes	2018-12-18
1	Los Angeles	Dina	Morin	2019-01-17
1	Los Angeles	Trystan	Oconnor	2019-02-28
1	San Diego	Marlene	Duncan	2019-06-13
1	San Diego	Marius	Powell	2019-11-13
2	San Diego	Marius	Williamson	2020-01-02
1	San Diego	Nora	Parkinson	2019-02-16
1	San Diego	Joanne	Goddard	2019-12-18

Comme vous pouvez le voir ci-dessus, la plupart des personnes sont classées en premier. Cela s'explique par le fait que la plupart des paires (ville et prénom) sont uniques. Cependant, il y a une paire qui n'est pas unique. Il y a deux personnes de San Diego qui s'appellent Marius. Marius Powell est le premier parce qu'il a passé l'examen plus tôt que Marius Williamson.

Rappelez-vous, c'est en forgeant qu'on devient forgeron

Comme vous pouvez le constater, les fonctions de classement en SQL sont utilisées dans de nombreux cas. Il est donc important de bien les connaître, car vous aurez probablement à écrire une requête de classement SQL tôt ou tard.

La meilleure façon d'apprendre les fonctions de classement (et les fonctions de fenêtre en général) est de s'exercer. Je vous recommande ce cours Fonctions de fenêtrage. Il comporte 218 exercices interactifs, ce qui équivaut à environ 20 heures de codage. C'est beaucoup, surtout si vous décidez de le faire en une seule fois. Nous ne le recommandons pas. Il est préférable de répartir vos études sur plusieurs jours. Vous trouverez ici d'autres conseils pour rester en bonne santé pendant l'apprentissage de SQL

Prenez soin de votre corps tout en développant votre carrière, et commencez à apprendre SQL dès aujourd'hui.

Nous avons également tout préparé au cas où vous n'auriez pas le temps d'effectuer un apprentissage approfondi, où vous auriez besoin de quelque chose pour vous aider en attendant, ou simplement d'une référence pour vous aider à vous souvenir de ce que vous avez appris. Nous avons tout compacté dans une antisèche SQL RANK, qui pourrait s'avérer utile dans de nombreuses situations.