Summary  
This chapter explains how to use the LIMIT clause in a SQL SELECT statement to restrict the number of rows returned by a query.

General domain of usage  
Database querying

We weten dat de `SELECT`-operator alle rijen uit een tabel kan ophalen van alle of specifieke kolommen. Maar wat als we slechts een bepaald aantal rijen willen ophalen?

Dit kan met de `LIMIT`-clausule. Deze wordt altijd aan het einde van de query gebruikt. De syntax is als volgt:

```sql
SELECT columns
FROM table 
LIMIT number_of_rows;
```

In het onderstaande voorbeeld worden de eerste 7 rijen (in dit geval, **de hoofdsteden van de landen**) uit de kolom opgehaald:

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 setUp(self):
        with open("query.sql", "r") as f:
            self.query = f.read()

    def test_result_three_distinct(self):
        """Check that query returns exactly 3 distinct continent values."""
        self.cursor.execute(self.query)
        rows = self.cursor.fetchall()
        continents = [row[0] for row in rows]
        unique_continents = set([c for c in continents if c is not None])
        correct_length = len(rows) == 3
        correct_distinct = len(unique_continents) == 3
        _dynamic_test(
            self,
            correct_length and correct_distinct,
            "Query returns exactly 3 distinct continent values.",
            f"Query must return exactly 3 distinct continent values. Got {len(rows)} rows and {len(unique_continents)} unique continents."
        )
    
    def test_select_distinct_used(self):
        """Check if SELECT DISTINCT is used on the continent column."""
        query = self.query.lower().replace("\\n", " ").replace("\t", " ")
        has_select_distinct = "distinct" in query
        _dynamic_test(
            self,
            has_select_distinct,
            "Query uses the DISTINCT keyword.",
            "Query must use the DISTINCT keyword."
        )

    def test_column_name_is_continent(self):
        """Check that the output column is named 'continent'."""
        self.cursor.execute(self.query)
        columns = [desc[0].lower() for desc in self.cursor.description]
        _dynamic_test(
            self,
            columns == ["continent"],
            "Output column is named 'continent'.",
            f"Output column should be named 'continent', got {columns}."
        )

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

Deze cursus is ideaal voor beginners die de wereld van SQL willen verkennen. Of je nu net begint met databasebeheer of SQL wilt gebruiken voor applicatieontwikkeling, deze cursus behandelt de basisprincipes. Je leert snel hoe je het volledige potentieel van SQL benut, van het opvragen en beheren van gegevens tot het naadloos integreren ervan in praktijktoepassingen. 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 gegevens die door een query worden opgehaald, kunnen worden georganiseerd en geprioriteerd met behulp van de ORDER BY-clausule. Deze clausule, geplaatst aan het einde van een SELECT-instructie, maakt het mogelijk om resultaten te sorteren op één of meerdere kolommen, in oplopende of aflopende volgorde, waardoor de gegevensuitvoer betekenisvoller en beter interpreteerbaar wordt.

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 behandelen we hoe u zoekvoorwaarden kunt verfijnen door WHERE-clausules te combineren met de AND- en OR-operatoren. We bespreken ook hoe de NOT-operator kan worden gebruikt om bepaalde resultaten uit te sluiten.

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

Resultaten Beperken

Oplossing

Resultaten Beperken

Oplossing