Summary  
This chapter covers using an ORDER BY clause to sort retrieved data by specified columns—defaulting to ascending order for numbers and alphabetical order for strings—and highlights placing ORDER BY before a LIMIT clause.

General domain of usage  
Relational database querying

De data du får kan sorteras i en specifik ordning. För att göra detta hämtar du först data med `SELECT`-satsen och tillämpar sedan `ORDER BY`-klasulen. Denna klausul tar **namn på kolumner** som resultatet ska sorteras efter.

Syntaxen är:

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

Följande exempel sorterar resultatet efter kolumnen `continent`:

SELECT continent 
FROM country 
ORDER BY continent;

Som standard sorterar `ORDER BY` i **stigande ordning** — numeriskt för numeriska kolumner och alfabetiskt för strängkolumner.

Dessutom ska `ORDER BY`-klausulen placeras precis före `LIMIT`-klausulen, om en `LIMIT`-klausul ingår i frågan.

**Förklaring:** I exemplet kan du se att `ORDER BY`-satsen sorterar data baserat på kolumnen `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

Utforska grunderna i SQL, från att hämta och filtrera data med SELECT och WHERE till att sortera resultat med ORDER BY och sammanfatta dem med aggregeringsfunktioner som COUNT, AVG och SUM. Genom praktiska övningar bygger du färdigheter för att säkert kunna göra frågor mot verkliga datamängder.

Upptäck hur du hämtar enskilda, flera och alla kolumner från en tabell med hjälp av SQL SELECT-satsen. Lär dig att returnera unika rader och begränsa antalet resultat som returneras av en fråga.

Upptäck hur du organiserar frågeresultat med hjälp av ORDER BY-satsen. Lär dig att sortera data efter en eller flera kolumner och kontrollera sorteringsriktningen med stigande eller fallande ordning för tydligare resultat.



Upptäck hur du filtrerar frågeresultat med WHERE-satsen. Lär dig att testa för likhet och olikhet, kontrollera värden mot ett intervall och identifiera NULL-värden i dina data.

Upptäck hur du kan förfina dina sökvillkor genom att kombinera WHERE-villkor med operatorerna AND och OR. Lär dig använda operatorn NOT för att exkludera specifika resultat från din fråga.



Upptäck hur du kan sammanfatta tabelldata med hjälp av SQL:s aggregeringsfunktioner. Lär dig att beräkna medelvärden och summor med AVG och SUM, räkna rader med COUNT samt hitta extremvärden med MAX och MIN.



Utmaning: Sortering av Data

Utmaning: Sortering av Data

Lösning