Summary  
This chapter explains how to sort query results using SQL’s ORDER BY clause to retrieve data in a specified order (ascending by default) and where to place it relative to a LIMIT clause.

General domain of usage  
Database querying

De ontvangen gegevens kunnen in een specifieke volgorde worden gesorteerd. Hiervoor wordt eerst de data opgehaald met de `SELECT`-instructie en vervolgens wordt de `ORDER BY`-clausule toegepast. Deze clausule gebruikt de **namen van kolommen** waarop de uitvoer wordt gesorteerd.

De syntaxis is als volgt:

```sql
SELECT columns
FROM table
ORDER BY column_name
```

Het volgende voorbeeld sorteert het resultaat op de kolom `continent`:

SELECT continent 
FROM country 
ORDER BY continent;

Standaard sorteert `ORDER BY` in **oplopende volgorde** — numeriek voor numerieke kolommen en alfabetisch voor tekstkolommen.

Daarnaast moet de `ORDER BY`-clausule direct vóór de `LIMIT`-clausule worden geplaatst, als er een `LIMIT`-clausule in de query is opgenomen.

**Uitleg:** In het voorbeeld zie je dat de `ORDER BY`-clausule de gegevens sorteert op basis van de kolom `continent`.


import unittest
import pandas as pd
import psycopg2

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_correct_output_sorted(self):
        """Check if capitals are selected and sorted alphabetically."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        capitals = [row[0] for row in rows]
        expected_capitals = [
            'Amsterdam', 'Asunción', 'Bangkok', 'Kyiv', 'Lisbon', 'Manila',
            'Mexico City', 'Monaco', 'Oslo', 'Riga', 'Stockholm', 'Tokyo',
            'Valletta', 'Washington', 'Wellington'
        ]
        capitals_no_spaces = [c.strip() for c in capitals]
        expected_capitals_no_spaces = [c.strip() for c in expected_capitals]
        is_sorted = capitals_no_spaces == sorted(expected_capitals_no_spaces)
        _dynamic_test(
            self,
            is_sorted,
            "Capitals are returned in alphabetical order.",
            f"Capitals are not sorted alphabetically. Got: {capitals_no_spaces}"
        )

    def test_only_capital_column_selected(self):
        """Check that only the 'capital' column is selected."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        _dynamic_test(
            self,
            columns == ['capital'],
            "Only 'capital' column is selected.",
            f"Unexpected columns selected: {columns}"
        )

    def test_no_syntax_error(self):
        """Check that query does not raise a syntax error."""
        with open("query.sql", "r") as file:
            query = file.read()
        try:
            self.cursor.execute(query)
            _dynamic_test(
                self,
                True,
                "Query executes without syntax error.",
                ""
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "",
                f"Query raised an error: {e}"
            )

    def test_table_and_column_exist(self):
        """Check that 'country' table and 'capital' column are referenced."""
        with open("query.sql", "r") as file:
            query = file.read().lower()
        has_country = 'from country' in query
        has_capital = 'select capital' in query
        _dynamic_test(
            self,
            has_country and has_capital,
            "Query references 'country' table and 'capital' column.",
            "Query must reference both 'country' table and 'capital' column."
        )

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)

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


test_solution.py

Ontdek de basisprincipes van SQL — van het opvragen van gegevens tot het integreren ervan in praktijktoepassingen. Of je nu net begint met databasebeheer of SQL wilt gebruiken voor applicatieontwikkeling, deze cursus behandelt de essentiële onderwerpen. Je leert snel het volledige potentieel van SQL benutten, van het opvragen en beheren van gegevens tot het naadloos integreren ervan in realistische toepassingen. Aan het einde van de cursus beschik je over het vertrouwen en de vaardigheden om praktische problemen met SQL op te lossen en je ontwikkelingsproces te verbeteren.

In deze sectie leren we hoe we de SQL SELECT-instructie gebruiken om één tabelkolom, meerdere tabelkolommen en alle tabelkolommen op te halen. We ontdekken ook hoe we unieke waarden kunnen retourneren.

In deze sectie onderzoeken we hoe u de gegevens die door een query worden opgehaald, kunt ordenen en prioriteren met behulp van de ORDER BY-clausule. Deze clausule, geplaatst aan het einde van een SELECT-instructie, stelt u in staat om uw resultaten te sorteren op één of meerdere kolommen, in oplopende of aflopende volgorde, waardoor de gegevensuitvoer betekenisvoller en gemakkelijker te interpreteren is.

In deze sectie leren we hoe we geretourneerde gegevens kunnen filteren met behulp van de WHERE-clausule van de SELECT-instructie. We behandelen het testen op gelijkheid, ongelijkheid, grotere en kleinere waarden, waarde-intervallen en NULL-waarden.

In deze sectie verkennen we hoe u zoekvoorwaarden kunt verfijnen door WHERE-clausules te combineren met de AND- en OR-operatoren. We behandelen ook hoe de NOT-operator kan worden gebruikt om bepaalde resultaten uit te sluiten.

In deze sectie leren we wat de SQL-aggregatiefuncties zijn en hoe deze gebruikt kunnen worden om tabelgegevens samen te vatten.

Gegevens Sorteren

Oplossing