Summary  
This chapter explains how to control sort direction in SQL queries using the ORDER BY clause with ASC and DESC, including sorting by multiple columns and assigning different directions to each.

General domain of usage  
Relational database querying

Watch this video to see how you can use the ORDER BY clause to sort data in descending order with the DESC keyword. You'll also learn how to sort by multiple columns and control the sort direction for each column in your SQL queries. Real examples with the country table will help you quickly understand how to apply these sorting techniques in practice.

## Sortering av kolumner i fallande ordning

Det är möjligt att göra mer än att bara sortera data i stigande ordning som standard. `ORDER BY`-satsen kan även ordna data i fallande ordning, vilket kräver användning av nyckelordet `DESC`.

SELECT continent 
FROM country 
ORDER BY continent DESC;

## Sortering av flera kolumner i fallande ordning

Det går att sortera data efter flera kolumner, och i många fall är detta faktiskt nödvändigt. Till exempel, vid visning av en lista med studenter kan det vara önskvärt att först sortera efter efternamn och därefter efter förnamn. Detta tillvägagångssätt är särskilt användbart när flera studenter har samma namn.

Om du sorterar i fallande ordning efter mer än en kolumn, kom ihåg att varje kolumn måste ha sitt eget `DESC`-nyckelord.

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

Det är endast nödvändigt att använda nyckelordet `DESC` på den kolumn som ska sorteras i fallande ordning. I vårt exempel användes `DESC` för kolumnen `name`, men inte för kolumnen `region`. Därför sorteras kolumnen `name` i fallande ordning, medan kolumnen `region` förblir sorterad i stigande ordning (standardinställningen).

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

Denna kurs är perfekt för nybörjare som vill utforska SQL-världen. Oavsett om du precis har börjat med databashantering eller vill använda SQL för dina applikationsutvecklingsprojekt, täcker denna kurs grunderna. Du lär dig snabbt att utnyttja hela potentialen med SQL, från att fråga och hantera data till att sömlöst integrera det i verkliga applikationer. Vid kursens slut har du självförtroendet och färdigheterna att lösa praktiska problem med SQL och förbättra din utvecklingsprocess.

I det här avsnittet kommer vi att lära oss hur man använder SQL SELECT-satsen för att hämta en enskild tabellkolumn, flera tabellkolumner och alla tabellkolumner. Vi kommer även att ta reda på hur man returnerar unika värden.

I det här avsnittet utforskar vi hur man organiserar och prioriterar data som returneras av en fråga med hjälp av ORDER BY-satsen. Denna sats placeras i slutet av ett SELECT-uttalande och gör det möjligt att sortera resultaten efter en eller flera kolumner, antingen i stigande eller fallande ordning, vilket ger en mer meningsfull och lättolkad datautmatning.

I det här avsnittet kommer vi att lära oss hur man filtrerar returnerad data med hjälp av SELECT-satsens WHERE-villkor. Vi kommer att lära oss hur man testar för likhet, olikhet, större och mindre än värdeintervall samt NULL-värden.

I det här avsnittet utforskar vi hur du kan förfina dina sökvillkor genom att kombinera WHERE-satser med operatorerna AND och OR. Vi går även igenom hur operatorn NOT kan användas för att exkludera vissa resultat.

I det här avsnittet kommer vi att lära oss vad SQL:s aggregatfunktioner är och hur de används för att sammanfatta tabelldata.

Ange Sorteringsriktning

Sortering av kolumner i fallande ordning

Sortering av flera kolumner i fallande ordning

Lösning