Summary  
This chapter explains how to retrieve multiple columns from a table by listing their names separated by commas in a SELECT statement.

General domain of usage  
Querying relational databases

## Inspectie van de tabel

Een nadere blik op de `country` database. Deze database bevat één tabel, eveneens genaamd `country`. Je bekijkt de gegevens in deze tabel nader.

Deze tabel bevat **15 rijen**, die 15 unieke records voor verschillende landen vertegenwoordigen.

De tabel bevat **7 kolommen**: `id`, `name`, `continent`, `region`, `SurfaceArea`, `capital` en `population`.

1. `id` - de unieke identificatie voor elk record;

2. `name` - de naam van het land;

3. `continent` - het continent waar het land zich bevindt;

4. `region` - de specifieke regio binnen het continent;

5. `SurfaceArea` - het totale landoppervlak van het land;

6. `capital` - de hoofdstad van het land;

7. `population` - het aantal inwoners van het land.



## De syntaxis voor het selecteren van meerdere kolommen

Voor het ophalen van meerdere kolommen gebruik je de `SELECT`-instructie. Na `SELECT` geef je de kolomnamen op die je wilt ophalen, gescheiden door komma's.

De syntaxis ziet er als volgt uit:

```sql
SELECT column1, column2, column3 
FROM table_name;
```

Hier is een voorbeeld van het selecteren van **drie** kolommen uit de `country`-tabel:

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_query_retrieves_correct_columns(self):
        """Check if query retrieves only 'continent' and 'population' columns from 'country'."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0].lower() for desc in self.cursor.description]
        expected_columns = ["continent", "population"]
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "The query retrieves only the 'continent' and 'population' columns in the correct order.",
            f"The query should retrieve only the columns 'continent' and 'population' in order, but got: {columns}."
        )

    def test_query_uses_correct_table(self):
        """Check if query returns the expected number of rows from 'country' table (should be 15)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        condition = len(rows) == 15
        _dynamic_test(
            self,
            condition,
            "The query uses the correct table and returns 15 rows.",
            f"The query should return 15 rows from the 'country' table, but got {len(rows)} rows."
        )

    def test_query_column_separator(self):
        """Check that both columns are selected and separated by a comma in the SELECT clause."""
        with open("query.sql", "r") as file:
            query = file.read().lower().replace("\\n", " ")
        # Find the SELECT ... FROM part
        select_from = query.split("from")[0]
        # Remove SELECT keyword
        select_columns = select_from.replace("select", "").strip()
        # Must contain a comma between 'continent' and 'population'
        has_comma = "," in select_columns
        has_continent = "continent" in select_columns
        has_population = "population" in select_columns
        condition = has_comma and has_continent and has_population
        _dynamic_test(
            self,
            condition,
            "The SELECT clause contains both columns separated by a comma.",
            "The SELECT clause must contain both 'continent' and 'population', separated by a comma."
        )

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 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.

Meerdere Kolommen Ophalen

Inspectie van de tabel

De syntaxis voor het selecteren van meerdere kolommen

Oplossing