Summary  
This chapter covers using the WHERE clause in SELECT statements to filter query results based on specified conditions and the proper placement of ORDER BY after filtering.  

General domain of usage  
Relational database querying

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

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

Bij het opgeven van een tekenreekswaarde, 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 moet `ORDER BY` altijd na `WHERE` komen.



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 ophalen en filteren van gegevens met SELECT en WHERE tot het sorteren van resultaten met ORDER BY en het samenvatten ervan met aggregatiefuncties zoals COUNT, AVG en SUM. Door middel van praktische uitdagingen ontwikkel je de vaardigheden om met vertrouwen echte datasets te bevragen.

Ontdek hoe u enkele, meerdere en alle kolommen uit een tabel ophaalt met de SQL SELECT-instructie. Leer hoe u unieke rijen retourneert en het aantal resultaten dat door een query wordt teruggegeven, beperkt.

Ontdek hoe u queryresultaten organiseert met de ORDER BY-clausule. Leer gegevens sorteren op één of meerdere kolommen en bepaal de sorteervolgorde met oplopende of aflopende volgorde voor een duidelijker resultaat.



Ontdek hoe u queryresultaten kunt filteren met de WHERE-clausule. Leer gelijkheid en ongelijkheid testen, waarden controleren binnen een bereik en NULL-waarden in uw gegevens identificeren.

Ontdek hoe u uw zoekvoorwaarden kunt verfijnen door WHERE-clausules te combineren met de AND- en OR-operatoren. Leer de NOT-operator te gebruiken om specifieke resultaten uit uw query uit te sluiten.



Ontdek hoe u tabelgegevens kunt samenvatten met behulp van SQL-aggregatiefuncties. Leer gemiddelden en totalen berekenen met AVG en SUM, rijen tellen met COUNT en extremen vinden met MAX en MIN.



Uitdaging: Gebruik van de WHERE-clausule

Positie van clausules

Uitdaging: Gebruik van de WHERE-clausule

Positie van clausules

Oplossing