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 ønsker at filtrere resultater ved hjælp af mere end én kolonne, kan du kæde betingelser sammen med `AND`-operatoren i `WHERE`-klausulen.

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

Denne forespørgsel returnerer kun de rækker, der opfylder begge betingelser: landets befolkning er mindst 1000000, og det er placeret 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

Dette kursus er ideelt for begyndere, der er klar til at udforske SQL-verdenen. Uanset om du lige er startet med databaseadministration eller ønsker at anvende SQL i dine applikationsudviklingsprojekter, dækker dette kursus det grundlæggende. Du lærer hurtigt at udnytte det fulde potentiale i SQL, fra forespørgsler og datastyring til problemfri integration i virkelige applikationer. Ved kursets afslutning vil du have selvtillid og færdigheder til at løse praktiske problemer med SQL og forbedre din udviklingsproces.

I dette afsnit lærer vi at bruge SQL SELECT-sætningen til at hente en enkelt tabelkolonne, flere tabelkolonner og alle tabelkolonner. Vi undersøger også, hvordan man returnerer unikke værdier.

I dette afsnit undersøger vi, hvordan man organiserer og prioriterer de data, der returneres af en forespørgsel ved hjælp af ORDER BY-klausulen. Placeret i slutningen af en SELECT-sætning gør denne klausul det muligt at sortere resultaterne efter én eller flere kolonner, enten i stigende eller faldende rækkefølge, hvilket giver et mere meningsfuldt og letfortolkeligt dataoutput.

I dette afsnit lærer vi, hvordan man filtrerer returnerede data ved hjælp af SELECT-sætningens WHERE-klausul. Vi gennemgår test for lighed, ulighed, større end og mindre end værdier samt NULL-værdier.

I dette afsnit undersøger vi, hvordan du kan forfine dine søgebetingelser ved at kombinere WHERE-klausuler med AND- og OR-operatorerne. Vi gennemgår også, hvordan NOT-operatoren kan bruges til at udelukke bestemte resultater.

I dette afsnit vil vi lære, hvad SQL-aggregatfunktioner er, og hvordan de bruges til at opsummere tabeldata.

Brug af AND-Operatoren

Løsning