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.

Per filtrare i risultati utilizzando più di una colonna, è possibile concatenare le condizioni con l'operatore `AND` nella clausola `WHERE`.

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

Questa query restituisce solo le righe che soddisfano entrambe le condizioni: la popolazione del paese è almeno 1000000 e si trova in 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

Questo corso è perfetto per principianti pronti a esplorare il mondo di SQL. Che tu stia iniziando a gestire database o desideri utilizzare SQL per i tuoi progetti di sviluppo applicazioni, questo corso copre gli elementi essenziali. Imparerai rapidamente a sfruttare tutto il potenziale di SQL, dalla query e gestione dei dati all'integrazione fluida nelle applicazioni reali. Al termine del corso, avrai la sicurezza e le competenze per risolvere problemi pratici con SQL e migliorare il tuo processo di sviluppo.

In questa sezione, apprenderemo come utilizzare l'istruzione SELECT di SQL per ottenere una singola colonna di una tabella, più colonne di una tabella e tutte le colonne di una tabella. Scopriremo inoltre come restituire valori unici.

In questa sezione, esamineremo come organizzare e dare priorità ai dati restituiti da una query utilizzando la clausola ORDER BY. Inserita alla fine di un'istruzione SELECT, questa clausola consente di ordinare i risultati in base a una o più colonne, sia in ordine crescente che decrescente, permettendo così una presentazione dei dati più significativa e facilmente interpretabile.

In questa sezione, apprenderemo come filtrare i dati restituiti utilizzando la clausola WHERE dell'istruzione SELECT. Impareremo come testare l'uguaglianza, la disuguaglianza, valori maggiori e minori rispetto a determinati intervalli e valori NULL.

In questa sezione, esploreremo come affinare le condizioni di ricerca combinando le clausole WHERE con gli operatori AND e OR. Verrà inoltre illustrato come l'operatore NOT possa essere utilizzato per escludere determinati risultati.

In questa sezione, apprenderemo cosa sono le funzioni di aggregazione in SQL e come utilizzarle per riassumere i dati delle tabelle.

Utilizzo dell'Operatore AND

Soluzione