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

I databaser innehåller tabeller vanligtvis stora mängder data. Ofta är du dock intresserad av att hämta specifika delar av datan istället för allt. För att göra detta behöver du ange villkor för datahämtning, vilket kallas filtreringskriterier.

Data filtreras med hjälp av en `WHERE`-sats som anger sökkriterierna i ett `SELECT`-kommando. `WHERE`-satsen placeras direkt efter tabellnamnet.

När du anger ett strängvärde, till exempel ett landsnamn, måste texten omges av enkla citattecken (`'`).



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

`SELECT`-satsen hämtar 2 kolumner från tabellen `country` och returnerar endast rader där värdet i kolumnen continent är `'Europe'`.

### Klausulernas ordning

Vid användning av `ORDER BY` och `WHERE`-klausuler, säkerställ att `ORDER BY` kommer efter `WHERE`.



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

Utforska grunderna i SQL, från att hämta och filtrera data med SELECT och WHERE till att sortera resultat med ORDER BY och sammanfatta dem med aggregeringsfunktioner som COUNT, AVG och SUM. Genom praktiska övningar bygger du färdigheter för att säkert kunna göra frågor mot verkliga datamängder.

Upptäck hur du hämtar enskilda, flera och alla kolumner från en tabell med hjälp av SQL SELECT-satsen. Lär dig att returnera unika rader och begränsa antalet resultat som returneras av en fråga.

Upptäck hur du organiserar frågeresultat med hjälp av ORDER BY-satsen. Lär dig att sortera data efter en eller flera kolumner och kontrollera sorteringsriktningen med stigande eller fallande ordning för tydligare resultat.



Upptäck hur du filtrerar frågeresultat med WHERE-satsen. Lär dig att testa för likhet och olikhet, kontrollera värden mot ett intervall och identifiera NULL-värden i dina data.

Upptäck hur du kan förfina dina sökvillkor genom att kombinera WHERE-villkor med operatorerna AND och OR. Lär dig använda operatorn NOT för att exkludera specifika resultat från din fråga.



Upptäck hur du kan sammanfatta tabelldata med hjälp av SQL:s aggregeringsfunktioner. Lär dig att beräkna medelvärden och summor med AVG och SUM, räkna rader med COUNT samt hitta extremvärden med MAX och MIN.



Utmaning: Användning av WHERE-satsen

Klausulernas ordning

Lösning