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.

I databaser innehåller tabeller vanligtvis stora datamängder. Ofta är vi dock intresserade av att hämta specifika delar av informationen snarare än allt. För att uppnå detta behöver vi definiera villkor för datahämtning, vilket kallas filtreringskriterier.

Data filtreras med hjälp av ett `WHERE`-villkor som anger sökkriterier i ett `SELECT`-uttryck. `WHERE`-villkoret placeras direkt efter tabellnamnet.

När ett strängvärde anges, 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älls att `ORDER BY` placeras efter `WHERE`-klausulen.



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

Denna kurs är perfekt för nybörjare som vill utforska SQL-världen. Oavsett om du precis har börjat med databashantering eller vill använda SQL för dina applikationsutvecklingsprojekt, täcker denna kurs grunderna. Du lär dig snabbt att utnyttja hela potentialen med SQL, från att fråga och hantera data till att sömlöst integrera det i verkliga applikationer. 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 utforskar vi 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 ett SELECT-uttalande och gör det möjligt att sortera resultaten efter en eller flera kolumner, antingen i stigande eller fallande ordning, vilket ger en mer meningsfull 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 lära oss hur man testar för likhet, olikhet, större 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