Summary  
This chapter explains how to implement code that retrieves data and orders the result set by multiple fields, where the first specified field has priority and subsequent fields resolve ties.

General domain of usage  
Tabular data querying in relational databases

Je kunt ook sorteren op meerdere kolommen. Je moet de kolomnamen **gescheiden door komma's** opgeven.

De eerste kolom die je opgeeft bij het sorteren krijgt **prioriteit**, daarna wordt er gesorteerd op de tweede kolom.

De syntaxis ziet er als volgt uit:

```sql
SELECT columns 
FROM table 
ORDER BY column_with_priority, column2, ...
```

Hier is een voorbeeld dat drie kolommen ophaalt en de resultaten sorteert op twee daarvan - eerst op `population` en daarna op `capital`:

SELECT ID, population, capital 
FROM country 
ORDER BY population, capital;

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_correct_columns_and_order(self):
        """Check that the query selects exactly the columns: continent, region, population, capital in that order."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        colnames = [desc[0] for desc in self.cursor.description]
        expected = ["continent", "region", "population", "capital"]
        condition = colnames == expected
        _dynamic_test(
            self,
            condition,
            "Query selects columns in correct order.",
            f"Expected columns {expected}, got {colnames}."
        )

    def test_order_by_continent_population(self):
        """Check that the result is ordered first by continent, then by population (ascending)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        if not rows or len(rows) < 2:
            _dynamic_test(
                self,
                True,
                "Result has less than 2 rows, ordering cannot be tested.",
                ""
            )
            return
        df = pd.DataFrame(rows, columns=[desc[0] for desc in self.cursor.description])
        # Sort with pandas to expected order
        expected_df = df.sort_values(by=["continent", "population"], ascending=[True, True], na_position='last').reset_index(drop=True)
        user_df = df.reset_index(drop=True)
        condition = expected_df[["continent", "population"]].equals(user_df[["continent", "population"]])
        _dynamic_test(
            self,
            condition,
            "Rows are ordered by continent and then by population.",
            "Rows are not ordered by continent and then by population."
        )

    def test_selects_from_country_table(self):
        """Check that the query selects from the country table (by verifying result matches expected rows from country table)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        self.cursor.execute("SELECT continent, region, population, capital FROM country ORDER BY continent, population;")
        expected_rows = self.cursor.fetchall()
        condition = user_rows == expected_rows
        _dynamic_test(
            self,
            condition,
            "Query retrieves correct rows from country table.",
            "Query does not retrieve correct rows from country table."
        )

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

Ontdek de basisprincipes van SQL, van het ophalen en filteren van gegevens met SELECT en WHERE tot het sorteren van resultaten met ORDER BY en het samenvatten ervan met aggregatiefuncties zoals COUNT, AVG en SUM. Door middel van praktische uitdagingen ontwikkel je de vaardigheden om met vertrouwen echte datasets te bevragen.

Ontdek hoe u enkele, meerdere en alle kolommen uit een tabel ophaalt met de SQL SELECT-instructie. Leer hoe u unieke rijen retourneert en het aantal resultaten dat door een query wordt teruggegeven, beperkt.

Ontdek hoe u queryresultaten organiseert met de ORDER BY-clausule. Leer gegevens sorteren op één of meerdere kolommen en bepaal de sorteervolgorde met oplopende of aflopende volgorde voor een duidelijker resultaat.



Ontdek hoe u queryresultaten kunt filteren met de WHERE-clausule. Leer gelijkheid en ongelijkheid testen, waarden controleren binnen een bereik en NULL-waarden in uw gegevens identificeren.

Ontdek hoe u uw zoekvoorwaarden kunt verfijnen door WHERE-clausules te combineren met de AND- en OR-operatoren. Leer de NOT-operator te gebruiken om specifieke resultaten uit uw query uit te sluiten.



Ontdek hoe u tabelgegevens kunt samenvatten met behulp van SQL-aggregatiefuncties. Leer gemiddelden en totalen berekenen met AVG en SUM, rijen tellen met COUNT en extremen vinden met MAX en MIN.



Uitdaging: Sorteren op Meerdere Kolommen

Oplossing