Summary  
This chapter covers using the ORDER BY clause in SQL to sort query results by one or more columns in ascending or descending order across various data types.

General domain of usage  
Database querying and data reporting

Watch this video for a clear explanation of how to sort data in SQL using the SELECT and ORDER BY clauses. You'll see practical examples of retrieving data from a table and arranging the results in a specific order, just as described in this chapter. This visual guide will reinforce your understanding of sorting data with SQL queries.

Vi kan sortere de data, vi modtager, i en bestemt rækkefølge. For at gøre dette henter vi først dataene ved hjælp af `SELECT`-operatoren og anvender derefter `ORDER BY`-klausulen. Denne klausul tager **navnene på kolonner** ud fra hvilke, outputtet vil blive sorteret.

Her er syntaksen for at illustrere dette:

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

Her er et eksempel, hvor vi sorterer resultatet efter kolonnen `continent`: 

SELECT continent 
FROM country 
ORDER BY continent;

Det er vigtigt at bemærke, at når du angiver en kolonne med heltalsværdier, vil sorteringen ske i **stigende rækkefølge**. For tekstkolonner vil sorteringen følge **alfabetisk rækkefølge**.

Desuden skal `ORDER BY`-klausulen placeres umiddelbart før `LIMIT`-klausulen, hvis en `LIMIT`-klausul er inkluderet i forespørgslen.

**Forklaring:** I eksemplet kan du se, at `ORDER BY`-klausulen sorterer dataene baseret på kolonnen `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

Dette kursus er ideelt for begyndere, der er klar til at udforske SQL-verdenen. Uanset om du lige er startet med databaseadministration eller ønsker at anvende SQL i dine applikationsudviklingsprojekter, dækker dette kursus det grundlæggende. Du lærer hurtigt at udnytte det fulde potentiale i SQL, fra forespørgsler og datastyring til problemfri integration i virkelige applikationer. Ved kursets afslutning vil du have selvtillid og færdigheder til at løse praktiske problemer med SQL og forbedre din udviklingsproces.

I dette afsnit lærer vi at bruge SQL SELECT-sætningen til at hente en enkelt tabelkolonne, flere tabelkolonner og alle tabelkolonner. Vi undersøger også, hvordan man returnerer unikke værdier.

I dette afsnit undersøger vi, hvordan man organiserer og prioriterer de data, der returneres af en forespørgsel ved hjælp af ORDER BY-klausulen. Placeret i slutningen af en SELECT-sætning gør denne klausul det muligt at sortere resultaterne efter én eller flere kolonner, enten i stigende eller faldende rækkefølge, hvilket giver et mere meningsfuldt og letfortolkeligt dataoutput.

I dette afsnit lærer vi, hvordan man filtrerer returnerede data ved hjælp af SELECT-sætningens WHERE-klausul. Vi gennemgår test for lighed, ulighed, større end og mindre end værdier samt NULL-værdier.

I dette afsnit undersøger vi, hvordan du kan forfine dine søgebetingelser ved at kombinere WHERE-klausuler med AND- og OR-operatorerne. Vi gennemgår også, hvordan NOT-operatoren kan bruges til at udelukke bestemte resultater.

I dette afsnit vil vi lære, hvad SQL-aggregatfunktioner er, og hvordan de bruges til at opsummere tabeldata.

Sortering af Data

Løsning