Comment utiliser ORDER BY en SQL pour trier les résultats d'une requête ?

La clause ORDER BY SQL sert à classer les lignes renvoyées par une requête selon un ou plusieurs critères. Elle permet, par exemple, d'afficher des clients par ordre alphabétique, des produits du plus cher au moins cher ou des commandes de la plus récente à la plus ancienne.

Sa syntaxe paraît simple, mais plusieurs détails comptent pour obtenir un résultat fiable : le sens du tri, l'ordre des colonnes, la gestion des égalités, la position des valeurs NULL et les différences entre MySQL, PostgreSQL, SQL Server ou Oracle.

Comment utiliser ORDER BY en SQL ?

La clause ORDER BY se place à la fin d'une requête SELECT, après les clauses de filtrage ou de regroupement. Elle reçoit une colonne, un alias ou une expression de tri, puis éventuellement le mot-clé ASC pour un ordre croissant ou DESC pour un ordre décroissant.

Quelle est la syntaxe de base de ORDER BY ?

La forme la plus simple consiste à sélectionner des colonnes, à indiquer la table source, puis à ajouter la colonne utilisée pour le classement :

SELECT nom, ville
FROM clients
ORDER BY nom;

Cette requête classe les clients selon leur nom. Comme aucun sens de tri n'est précisé, SQL applique l'ordre croissant par défaut. Pour une colonne de texte, cela correspond généralement à un classement de A à Z. Pour un nombre, les valeurs vont de la plus petite à la plus grande. Pour une date, les plus anciennes apparaissent en premier.

Comment choisir entre ASC et DESC ?

ASC signifie ascendant et DESC descendant. Le mot-clé ASC reste facultatif, mais l'écrire peut rendre une requête multicritère plus facile à relire.

SELECT nom, prix
FROM produits
ORDER BY prix ASC;

Cette première requête affiche les produits du moins cher au plus cher. Pour inverser le classement, il suffit d'utiliser DESC :

SELECT nom, prix
FROM produits
ORDER BY prix DESC;

Le même principe s'applique aux dates. Pour afficher les dernières commandes en premier, la requête devient :

SELECT id_commande, date_commande, montant
FROM commandes
ORDER BY date_commande DESC;

Dans quel ordre placer ORDER BY dans une requête SQL ?

Dans l'écriture d'une requête, ORDER BY intervient après WHERE, GROUP BY et HAVING. Il se place généralement avant la clause qui limite les résultats, comme LIMIT, OFFSET ou FETCH. Le moteur filtre et regroupe donc les données avant de trier le résultat final.

Quel est l'ordre d'écriture des principales clauses SQL ?

Pour une requête de lecture classique, l'ordre d'écriture le plus courant est le suivant :

1. SELECT pour choisir les colonnes à renvoyer ;
2. FROM et les éventuelles jointures pour définir les sources ;
3. WHERE pour filtrer les lignes ;
4. GROUP BY pour former des groupes ;
5. HAVING pour filtrer les groupes ;
6. ORDER BY pour classer le résultat ;
7. LIMIT, OFFSET ou FETCH pour limiter les lignes, selon le SGBD.

Voici un exemple qui calcule le chiffre d'affaires par client, écarte les groupes dont le total ne dépasse pas 1 000, puis classe les résultats du montant le plus élevé au plus faible :

SELECT client_id, SUM(montant) AS chiffre_affaires
FROM commandes
WHERE statut = 'payee'
GROUP BY client_id
HAVING SUM(montant) > 1000
ORDER BY chiffre_affaires DESC;

Pourquoi faut-il prévoir un critère de départage ?

Lorsque plusieurs lignes possèdent la même valeur dans la première colonne de tri, leur ordre relatif n'est pas forcément stable. Pour obtenir un classement déterministe, notamment avec une pagination, ajoutez un second critère unique ou suffisamment discriminant.

SELECT id, nom, date_inscription
FROM utilisateurs
ORDER BY date_inscription DESC, id DESC;

Ici, date_inscription constitue le tri principal. Si deux utilisateurs ont exactement la même date d'inscription, l'identifiant les départage. Cette précaution évite qu'une ligne change de page entre deux exécutions d'une requête paginée.

Comment trier une requête SQL sur plusieurs colonnes ?

Pour appliquer plusieurs critères, séparez les colonnes par des virgules. SQL trie d'abord toutes les lignes selon la première colonne. Il utilise la deuxième uniquement pour départager les lignes ayant la même première valeur, puis la troisième en cas de nouvelle égalité.

SELECT nom, ville, date_inscription
FROM clients
ORDER BY ville ASC, nom ASC, date_inscription DESC;

Le résultat est d'abord classé par ville. Dans chaque ville, les clients sont rangés par nom. Lorsque plusieurs lignes partagent aussi le même nom, la date d'inscription la plus récente passe en premier.

Peut-on mélanger ASC et DESC ?

Chaque critère peut avoir son propre sens de tri. Il est donc possible de classer les catégories par ordre alphabétique tout en affichant, dans chaque catégorie, les prix les plus élevés en premier :

SELECT categorie, nom, prix
FROM produits
ORDER BY categorie ASC, prix DESC, nom ASC;

L'ordre des colonnes après ORDER BY est décisif. Écrire ORDER BY prix DESC, categorie ASC ne produit pas le même résultat, car le prix devient alors le critère principal.

Comment ORDER BY gère-t-il les valeurs NULL ?

Le comportement des valeurs NULL n'est pas identique dans tous les systèmes de gestion de base de données. MySQL et SQL Server les placent généralement avant les valeurs non nulles lors d'un tri croissant. PostgreSQL et Oracle les placent généralement à la fin dans la même situation.

Comment imposer la position des NULL avec PostgreSQL ou Oracle ?

PostgreSQL et Oracle permettent d'indiquer explicitement la position des valeurs manquantes avec NULLS FIRST ou NULLS LAST :

SELECT nom, telephone
FROM clients
ORDER BY telephone ASC NULLS LAST;

Cette requête place les numéros connus en premier et les valeurs NULL à la fin, indépendamment du comportement par défaut attendu pour ce tri.

Comment placer les NULL à la fin avec MySQL ou SQL Server ?

Lorsque NULLS LAST n'est pas pris en charge, un premier critère conditionnel peut séparer les valeurs nulles des autres :

SELECT nom, telephone
FROM clients
ORDER BY
  CASE WHEN telephone IS NULL THEN 1 ELSE 0 END,
  telephone ASC;

Le premier critère attribue 0 aux numéros présents et 1 aux valeurs absentes. Les lignes non nulles sont donc classées avant les autres, puis les numéros sont triés dans l'ordre croissant.

Quelle est la différence entre ORDER BY et GROUP BY ?

GROUP BY rassemble des lignes qui partagent une ou plusieurs valeurs afin de calculer des agrégats comme COUNT(), SUM() ou AVG(). ORDER BY ne regroupe rien : il classe les lignes ou les groupes du résultat final.

Pour compter le nombre de visites par jour, utilisez GROUP BY :

SELECT date_visite, COUNT(*) AS nombre_visites
FROM visites
GROUP BY date_visite;

Cette requête crée une ligne de résultat par date, mais elle ne garantit pas l'ordre d'affichage. Pour obtenir les jours les plus récents en premier, ajoutez ensuite ORDER BY :

SELECT date_visite, COUNT(*) AS nombre_visites
FROM visites
GROUP BY date_visite
ORDER BY date_visite DESC;

Les deux clauses ne sont donc pas concurrentes. Elles répondent à des besoins différents et peuvent être utilisées ensemble dans la même requête.

Comment créer un ordre de tri personnalisé en SQL ?

Un classement métier ne correspond pas toujours à l'ordre alphabétique ou numérique. Une commande peut, par exemple, passer par les statuts « en attente », « payée », « expédiée » puis « livrée ». Une expression CASE permet d'associer chaque statut à une priorité.

SELECT id_commande, statut, date_commande
FROM commandes
ORDER BY
  CASE statut
    WHEN 'en_attente' THEN 1
    WHEN 'payee' THEN 2
    WHEN 'expediee' THEN 3
    WHEN 'livree' THEN 4
    ELSE 5
  END,
  date_commande DESC;

Les commandes sont d'abord classées selon la priorité définie par le CASE. À statut égal, la date la plus récente passe en premier.

Peut-on trier avec un alias ou une expression ?

Dans de nombreux SGBD, ORDER BY peut utiliser un alias créé dans la clause SELECT :

SELECT nom, prix_ht * 1.20 AS prix_ttc
FROM produits
ORDER BY prix_ttc DESC;

Il est aussi possible de trier avec la position d'une colonne, par exemple ORDER BY 2. Cette écriture reste fragile : une modification de l'ordre des colonnes dans SELECT peut changer silencieusement le classement. Nommer la colonne ou son alias rend la requête plus lisible et plus facile à maintenir.

Comment améliorer les performances d'un ORDER BY SQL ?

Un tri peut devenir coûteux lorsqu'il porte sur un grand nombre de lignes. Le moteur doit parfois créer une structure temporaire en mémoire ou sur disque avant de renvoyer le résultat. Il n'existe toutefois pas d'optimisation universelle : le plan choisi dépend du SGBD, des index, du filtre et du volume de données.

Un index accélère-t-il toujours ORDER BY ?

Un index peut éviter ou réduire une opération de tri lorsque son ordre correspond aux colonnes utilisées par la requête. Pour un tri sur ville puis nom, un index composite commençant par ces deux colonnes peut être pertinent :

CREATE INDEX idx_clients_ville_nom
ON clients (ville, nom);

Cet index n'est pas automatiquement le meilleur choix. Sa pertinence dépend aussi des conditions WHERE, des jointures, du sens de tri, du nombre de lignes retournées et du coût des écritures supplémentaires. Utilisez le plan d'exécution, avec EXPLAIN ou l'outil équivalent de votre SGBD, avant de créer un index uniquement pour une requête.

Quelles pratiques réduisent le coût du tri ?

• Filtrer les lignes le plus précisément possible avec WHERE avant le tri.
• Ne sélectionner que les colonnes nécessaires au lieu d'utiliser systématiquement SELECT *.
• Associer ORDER BY à une limitation cohérente lorsque seuls les premiers résultats sont utiles.
• Créer un index composite dont l'ordre correspond réellement aux filtres et aux critères de tri.
• Vérifier le plan d'exécution plutôt que de supposer que l'index sera utilisé.
• Ajouter un critère unique lors d'une pagination pour conserver un ordre stable.

Quelles erreurs éviter avec ORDER BY ?

• Supposer qu'une table possède un ordre naturel. Sans ORDER BY, l'ordre des lignes n'est pas garanti.
• Inverser l'ordre des critères dans un tri multicritère. La première colonne reste toujours prioritaire.
• Oublier que le classement des textes dépend de la collation, notamment pour la casse et les accents.
• Utiliser un numéro de colonne comme ORDER BY 2 dans une requête appelée à évoluer.
• Confondre regroupement et classement. GROUP BY ne remplace pas ORDER BY.
• Paginer sur une colonne comportant des doublons sans ajouter de critère de départage.
• Créer un index sans mesurer son effet sur le plan d'exécution et sur les opérations d'écriture.

Une clause ORDER BY fiable précise donc le sens du tri, hiérarchise clairement les critères et prévoit les égalités. Pour une requête utilisée en production, le bon réflexe consiste à vérifier à la fois la stabilité du résultat et le plan d'exécution.