Summary
This chapter explains how to control the sort direction in an SQL ORDER BY clause using the DESC keyword for descending order, including how to apply it selectively to single or multiple columns.

General domain of usage
Relational database querying

## Tri des colonnes par ordre décroissant

Il est possible de trier les données non seulement par ordre croissant par défaut, mais aussi par ordre décroissant. La clause `ORDER BY` permet d'organiser les données en ordre décroissant en utilisant le mot-clé `DESC`.

SELECT continent 
FROM country 
ORDER BY continent DESC;

## Tri de plusieurs colonnes par ordre décroissant

Il est possible de trier les données selon plusieurs colonnes, ce qui est souvent nécessaire. Lors de l'affichage d'une liste d'étudiants, il peut être utile de les classer d'abord par nom de famille, puis par prénom. Cette méthode est particulièrement utile lorsque plusieurs étudiants portent le même nom.

De plus, lors d'un tri décroissant sur plusieurs colonnes, il est important d'ajouter le mot-clé `DESC` à chaque colonne concernée.

SELECT id, name, region 
FROM country 
ORDER BY region, name DESC;

Il suffit d'appliquer le mot-clé `DESC` à la colonne que vous souhaitez trier par ordre décroissant. Dans cet exemple, `DESC` est utilisé pour la colonne `name` mais pas pour la colonne `region`. Ainsi, la colonne `name` est triée par ordre décroissant, tandis que la colonne `region` reste triée par ordre croissant (valeur par défaut).

import unittest
import psycopg2
import pandas as pd

class TestTask(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.connection = psycopg2.connect(
            host="localhost",
            user="agent",
            password="qwerty",
            dbname="testdb",
            sslmode="disable"
        )
        cls.cursor = cls.connection.cursor()

    def test_selects_five_columns_in_order(self):
        """Test that the query selects columns in the correct order: name, continent, region, population, capital."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        expected_columns = ["name", "continent", "region", "population", "capital"]
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "Query selects the correct columns in the correct order.",
            f"Columns selected are {columns}, but expected {expected_columns}."
        )

    def test_order_by_continent_desc_population_asc(self):
        """Test that the result is ordered by continent DESC, then population ASC."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        # Get the indexes for continent and population
        columns = [desc[0] for desc in self.cursor.description]
        continent_idx = columns.index("continent")
        population_idx = columns.index("population")
        # Prepare list of (continent, population) for comparison
        order_pairs = [(row[continent_idx], row[population_idx]) for row in rows]
        # Compare with expected ordering
        sorted_pairs = sorted(order_pairs, key=lambda x: (x[0] is not None and x[0] or '', x[1] if x[1] is not None else float('inf')), reverse=False)
        # continent DESC, population ASC
        # So, for continent, need descending
        sorted_pairs = sorted(order_pairs, key=lambda x: ((x[0] is not None and x[0] or ''), x[1] if x[1] is not None else float('inf')))
        sorted_pairs = sorted(sorted_pairs, key=lambda x: (x[0] is not None and x[0] or ''), reverse=True)
        # Now, compare to actual
        # But above sorts in two steps: first by population ASC, then by continent DESC
        # Instead, use a tuple: (-continent, population) but continent is string
        # So, do a single sort:
        expected_pairs = sorted(order_pairs, key=lambda x: ((x[0] is not None and x[0] or ''), x[1] if x[1] is not None else float('inf')), reverse=False)
        expected_pairs = sorted(expected_pairs, key=lambda x: (x[0] is not None and x[0] or ''), reverse=True)
        condition = order_pairs == expected_pairs
        _dynamic_test(
            self,
            condition,
            "Rows are ordered by continent DESC, then population ASC.",
            "Rows are not ordered by continent DESC, then population ASC."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

if __name__ == "__main__":
    unittest.main()


test_solution.py

Découvrez les bases de SQL — de l'interrogation des données à leur intégration dans des applications concrètes. Que vous débutiez en gestion de bases de données ou que vous souhaitiez utiliser SQL pour vos projets de développement applicatif, ce cours couvre les fondamentaux. Vous apprendrez rapidement à exploiter tout le potentiel de SQL, de l'interrogation et la gestion des données à leur intégration fluide dans des applications réelles. À la fin du cours, vous aurez la confiance et les compétences nécessaires pour résoudre des problèmes pratiques avec SQL et améliorer votre processus de développement.

Dans cette section, nous apprendrons à utiliser l'instruction SELECT de SQL pour obtenir une colonne de table, plusieurs colonnes de table et toutes les colonnes de table. Nous découvrirons également comment retourner des valeurs uniques.

Dans cette section, nous examinerons comment organiser et hiérarchiser les données renvoyées par une requête à l'aide de la clause ORDER BY. Placée à la fin d'une instruction SELECT, cette clause permet de trier les résultats selon une ou plusieurs colonnes, en ordre croissant ou décroissant, offrant ainsi une sortie de données plus significative et facile à interpréter.

Dans cette section, nous apprendrons à filtrer les données retournées à l'aide de la clause WHERE de l'instruction SELECT. Nous verrons comment tester l'égalité, l'inégalité, les plages de valeurs supérieures et inférieures, ainsi que les valeurs NULL.

Dans cette section, nous explorerons comment affiner vos conditions de recherche en combinant les clauses WHERE avec les opérateurs AND et OR. Nous aborderons également l'utilisation de l'opérateur NOT pour exclure certains résultats.

Dans cette section, nous découvrirons ce que sont les fonctions d'agrégation SQL et comment les utiliser pour résumer les données d'une table.

Spécification de la Direction de Tri

Tri des colonnes par ordre décroissant

Tri de plusieurs colonnes par ordre décroissant

Solution