Summary  
This chapter explains how to use the AND operator to combine multiple conditions in a WHERE clause for filtering query results.

General domain of usage  
Relational database querying

Når du vil filtrere resultater ved å bruke mer enn én kolonne, kan du koble sammen betingelser med `AND`-operatoren i `WHERE`-setningen.

SELECT name, population, region
FROM country
WHERE population >= 1000000 AND continent = 'Europe';

Denne spørringen returnerer kun radene som oppfyller begge betingelsene: landets befolkning er minst 1000000, og det ligger i Europa.

import unittest
import psycopg2
import pandas as pd
import re

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_selects_only_name_column(self):
        """Check if only the 'name' column is selected."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        condition = len(columns) == 1 and normalize_text(columns[0]) == 'name'
        _dynamic_test(
            self,
            condition,
            "Query selects only the 'name' column.",
            f"Query must select only the 'name' column, but got: {columns}."
        )

    def test_population_greater_than_1000000(self):
        """Check if all returned countries have population > 1000000."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        names = [row[0] for row in self.cursor.fetchall()]
        if not names:
            # No rows returned, cannot verify, consider as fail
            _dynamic_test(
                self,
                False,
                "Rows with population > 1000000 are returned.",
                "No rows returned. Ensure you are filtering population > 1000000."
            )
            return
        # Get populations for returned names
        format_names = ','.join(['%s']*len(names))
        self.cursor.execute(f"SELECT name, population FROM country WHERE name IN ({format_names})", names)
        for name, population in self.cursor.fetchall():
            condition = population is not None and population > 1000000
            _dynamic_test(
                self,
                condition,
                f"Country '{name}' has population > 1000000.",
                f"Country '{name}' does not have population > 1000000."
            )

    def test_continent_is_asia(self):
        """Check if all returned countries are in Asia."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        names = [row[0] for row in self.cursor.fetchall()]
        if not names:
            _dynamic_test(
                self,
                False,
                "Rows from Asia are returned.",
                "No rows returned. Ensure you are filtering continent = 'Asia'."
            )
            return
        format_names = ','.join(['%s']*len(names))
        self.cursor.execute(f"SELECT name, continent FROM country WHERE name IN ({format_names})", names)
        for name, continent in self.cursor.fetchall():
            condition = normalize_text(continent) == 'asia'
            _dynamic_test(
                self,
                condition,
                f"Country '{name}' is in Asia.",
                f"Country '{name}' is not in Asia."
            )

    def test_and_operator_used(self):
        """Check if query uses the AND operator in WHERE clause."""
        with open("query.sql", "r") as file:
            query = file.read()
        lower_query = normalize_text(query)
        # Find WHERE ... AND ...
        # Accepts both orders
        has_and = 'where' in lower_query and 'and' in lower_query
        _dynamic_test(
            self,
            has_and,
            "Query uses the AND operator in WHERE clause.",
            "Query must use the AND operator to combine conditions in WHERE clause."
        )

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

Utforsk det grunnleggende i SQL, fra å hente og filtrere data med SELECT og WHERE til å sortere resultater med ORDER BY og oppsummere dem med aggregeringsfunksjoner som COUNT, AVG og SUM. Gjennom praktiske utfordringer bygger du ferdigheter til å utføre spørringer på reelle datasett med trygghet.

Utforsk hvordan du henter én, flere eller alle kolonner fra en tabell ved hjelp av SQL SELECT-setningen. Lær å returnere distinkte rader og begrense antall resultater som returneres av en spørring.

Lær hvordan du organiserer spørringsresultater ved hjelp av ORDER BY-setningen. Forstå hvordan du sorterer data etter én eller flere kolonner, og styr sorteringsretningen med stigende eller synkende rekkefølge for tydeligere resultater.



Utforsk hvordan du kan filtrere spørringsresultater ved hjelp av WHERE-setningen. Lær å teste for likhet og ulikhet, kontrollere verdier mot et intervall, og identifisere NULL-verdier i dataene dine.

Utforsk hvordan du kan forbedre søkekriteriene ved å kombinere WHERE-setninger med AND- og OR-operatorene. Lær å bruke NOT-operatoren for å utelukke spesifikke resultater fra spørringen din.



Utforsk hvordan du kan oppsummere tabelldata ved hjelp av SQL-aggregeringsfunksjoner. Lær å beregne gjennomsnitt og totaler med AVG og SUM, telle rader med COUNT, og finne ytterverdier med MAX og MIN.



Utfordring: Bruk av AND-Operatoren

Løsning