Summary  
This chapter covers using the AND operator to combine multiple conditions in a WHERE clause so that only records satisfying all criteria are returned.

General domain of usage  
Querying relational databases

Watch this video to learn how to use the AND operator in SQL WHERE clauses. You'll see how to filter data by combining multiple conditions, so only the rows that meet all criteria are returned. The video demonstrates step-by-step examples using real table data to help you understand how AND works in practice.

När du vill filtrera resultat med hjälp av mer än en kolumn kan du länka villkor tillsammans med operatorn `AND` i `WHERE`-satsen.

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

Denna fråga returnerar endast de rader som uppfyller båda villkoren: landets befolkning är minst 1000000 och det är beläget 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

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 AND-Operatorn

Lösning