Summary  
This chapter explains how to use the SQL WHERE clause in a SELECT statement to filter rows based on conditions (e.g., equals, greater than, less than, not equal).

General domain of usage  
Relational database querying

This video demonstrates how to use the WHERE clause in SQL to filter data from a table. You will see how to write a SELECT statement with a WHERE clause, specify conditions for filtering rows, and understand where the WHERE clause fits in the query structure. Real examples using the country table will help you see how to retrieve only the rows that match your criteria, such as selecting countries from a specific continent.

In databases bevatten tabellen doorgaans grote hoeveelheden gegevens. Vaak is echter slechts een specifiek deel van deze gegevens relevant. Om dit te bereiken, moeten de voorwaarden voor het ophalen van gegevens worden gedefinieerd; deze worden aangeduid als filtercriteria.

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

Bij het specificeren van een tekenreekswaarde, zoals een landnaam, moet de tekst tussen enkele aanhalingstekens (`'`) worden geplaatst.



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

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

### Positie van clausules

Bij gebruik van de `ORDER BY`- en `WHERE`-clausules komt de `ORDER BY` altijd na de `WHERE`-clausule.



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

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.

Het Gebruik van de WHERE-Clausule

Positie van clausules

Oplossing