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

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 ett `WHERE`-villkor som anger sökkriterierna i ett `SELECT`-uttryck. `WHERE`-villkoret placeras direkt efter tabellnamnet.

När du anger ett strängvärde, till exempel ett landsnamn, måste texten omslutas 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'`.

### Klausulens position

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 data till att integrera det i verkliga applikationer. Oavsett om du precis har börjat med databashantering eller vill använda SQL i dina utvecklingsprojekt, täcker denna kurs det väsentliga. Du lär dig snabbt att utnyttja SQL:s fulla potential, från att fråga och hantera data till att sömlöst integrera det i praktiska tillämpningar. Vid kursens slut har du självförtroendet och färdigheterna att lösa praktiska problem med SQL och förbättra din utvecklingsprocess.

I det här avsnittet kommer vi att lära oss hur man använder SQL SELECT-satsen för att hämta en enskild tabellkolumn, flera tabellkolumner och alla tabellkolumner. Vi kommer även att ta reda på hur man returnerar unika värden.

I det här avsnittet kommer vi att utforska hur man organiserar och prioriterar data som returneras av en fråga med hjälp av ORDER BY-satsen. Denna sats placeras i slutet av en SELECT-sats och gör det möjligt att sortera resultaten efter en eller flera kolumner, antingen i stigande eller fallande ordning, vilket ger ett mer meningsfullt och lättolkad datautmatning.

I det här avsnittet kommer vi att lära oss hur man filtrerar returnerad data med hjälp av SELECT-satsens WHERE-villkor. Vi kommer att gå igenom hur man testar för likhet, olikhet, större än och mindre än värdeintervall samt NULL-värden.

I det här avsnittet utforskar vi hur du kan förfina dina sökvillkor genom att kombinera WHERE-satser med operatorerna AND och OR. Vi går även igenom hur operatorn NOT kan användas för att exkludera vissa resultat.

I det här avsnittet kommer vi att lära oss vad SQL:s aggregatfunktioner är och hur de används för att sammanfatta tabelldata.

Använda WHERE-satsen

Klausulens position

Lösning