Summary  
This chapter explains how to filter query results using the WHERE clause in SELECT statements—showing how to specify search criteria (including string literals) and the proper placement of ORDER BY after WHERE.

General domain of usage  
Database querying

In databases bevatten tabellen doorgaans grote hoeveelheden gegevens. Vaak ben je echter alleen geïnteresseerd in het ophalen van specifieke delen van deze gegevens in plaats van alles. Om dit te bereiken, moet je de voorwaarden voor het ophalen van gegevens definiëren, die worden aangeduid als filtercriteria.

Gegevens worden gefilterd met behulp van een `WHERE`-clausule waarin de zoekcriteria worden gespecificeerd in een `SELECT`-statement. De `WHERE`-clausule volgt direct na de tabelnaam.

Wanneer je een tekenreekswaarde opgeeft, zoals een landnaam, moet je de tekst tussen enkele aanhalingstekens (`'`) plaatsen.



SELECT name, continent 
FROM country 
WHERE continent= 'Europe';

De `SELECT`-instructie haalt 2 kolommen op uit de `country`-tabel en retourneert alleen rijen met de continentwaarde `'Europe'`.

### Positie van clausules

Bij gebruik van `ORDER BY` en `WHERE`-clausules, ervoor zorgen dat `ORDER BY` na `WHERE` komt.



SELECT capital, continent 
FROM country 
WHERE continent='Asia'
ORDER BY continent DESC;

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_returns_correct_rows(self):
        """Check that only countries from 'North America' are returned with correct columns."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Run user query
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        df = pd.DataFrame(rows, columns=columns)

        # Solution dataframe
        self.cursor.execute("""
            SELECT id, name, region FROM country WHERE continent='North America';
        """)
        sol_rows = self.cursor.fetchall()
        sol_columns = [desc[0] for desc in self.cursor.description]
        sol_df = pd.DataFrame(sol_rows, columns=sol_columns)

        # Check matching rows and shape
        condition = df.shape == sol_df.shape and df.equals(sol_df)
        _dynamic_test(
            self,
            condition,
            "Query returns only the correct rows from 'North America' with correct columns.",
            f"Query did not return the correct rows or columns for 'North America'. Expected:\\n{sol_df}\\nGot:\\n{df}"
        )

    def test_column_order_and_names(self):
        """Check that columns are exactly id, name, region (in this order)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        expected = ["id", "name", "region"]
        condition = columns == expected
        _dynamic_test(
            self,
            condition,
            "Columns are in the correct order: id, name, region.",
            f"Columns are not in the correct order. Expected: {expected}, 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

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.

Het Gebruik van de WHERE-clausule

Positie van clausules

Oplossing