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 Datenbanken enthalten Tabellen typischerweise große Datenmengen. Häufig besteht jedoch Interesse daran, nur bestimmte Teile der Daten abzurufen, anstatt die Gesamtheit. Um dies zu erreichen, müssen die Bedingungen für die Datenabfrage definiert werden, die als Filterkriterien bezeichnet werden.

Daten werden mit einer `WHERE`-Klausel gefiltert, die die Suchkriterien in einer `SELECT`-Anweisung angibt. Die `WHERE`-Klausel steht unmittelbar nach dem Tabellennamen.

Bei der Angabe eines Zeichenkettenwerts, wie beispielsweise eines Ländernamens, muss der Text in einfache Anführungszeichen (`'`) gesetzt werden.



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

Die `SELECT`-Anweisung ruft 2 Spalten aus der Tabelle `country` ab und gibt nur Zeilen mit dem Kontinentwert `'Europe'` zurück.

### Position der Klausel

Beim Verwenden von `ORDER BY`- und `WHERE`-Klauseln darauf achten, dass `ORDER BY` nach `WHERE` steht.



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

Erkunden Sie die Grundlagen von SQL – von der Abfrage von Daten bis zur Integration in reale Anwendungen. Ob Sie gerade erst mit dem Datenbankmanagement beginnen oder SQL für Ihre Anwendungsentwicklungsprojekte nutzen möchten, dieser Kurs behandelt die wichtigsten Aspekte. Sie lernen schnell, das volle Potenzial von SQL auszuschöpfen, von der Abfrage und Verwaltung von Daten bis zur nahtlosen Integration in reale Anwendungen. Am Ende des Kurses verfügen Sie über das nötige Selbstvertrauen und die Fähigkeiten, um praktische Probleme mit SQL zu lösen und Ihren Entwicklungsprozess zu optimieren.

In diesem Abschnitt lernen wir, wie man mit der SQL-SELECT-Anweisung eine einzelne Tabellenspalte, mehrere Tabellenspalten und alle Tabellenspalten abruft.
Wir erfahren außerdem, wie man eindeutige Werte zurückgibt.

In diesem Abschnitt untersuchen wir, wie die durch eine Abfrage zurückgegebenen Daten mithilfe der ORDER BY-Klausel organisiert und priorisiert werden können. Diese Klausel wird am Ende einer SELECT-Anweisung platziert und ermöglicht es, die Ergebnisse nach einer oder mehreren Spalten entweder in aufsteigender oder absteigender Reihenfolge zu sortieren, was eine aussagekräftigere und leichter interpretierbare Datenausgabe ermöglicht.

In diesem Abschnitt lernen wir, wie man mit der WHERE-Klausel der SELECT-Anweisung zurückgegebene Daten filtert. Es wird gezeigt, wie man auf Gleichheit, Ungleichheit, Wertebereiche mit größer oder kleiner als sowie auf NULL-Werte prüft.

In diesem Abschnitt werden wir untersuchen, wie Sie Ihre Suchbedingungen durch die Kombination von WHERE-Klauseln mit den Operatoren AND und OR verfeinern können. Außerdem behandeln wir, wie der Operator NOT verwendet werden kann, um bestimmte Ergebnisse auszuschließen.

In diesem Abschnitt lernen wir, was SQL-Aggregatfunktionen sind und wie sie verwendet werden, um Tabellendaten zusammenzufassen.

Verwendung der WHERE-Klausel

Position der Klausel

Lösung