Summary  
This chapter explains how to use the AND operator to combine multiple conditions in a WHERE clause so that only records meeting all specified criteria are returned.

General domain of usage  
Database querying

Para filtrar resultados utilizando más de una columna, se pueden encadenar condiciones con el operador `AND` en la cláusula `WHERE`.

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

Esta consulta devuelve únicamente las filas que cumplen ambas condiciones: la población del país es al menos 1000000 y está ubicado en 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

Explora los conceptos esenciales de SQL: desde la consulta de datos hasta su integración en aplicaciones del mundo real. Tanto si estás comenzando en la gestión de bases de datos como si buscas utilizar SQL en proyectos de desarrollo de aplicaciones, este curso abarca los fundamentos. Aprenderás rápidamente a aprovechar todo el potencial de SQL, desde la consulta y gestión de datos hasta su integración fluida en aplicaciones reales. Al finalizar el curso, contarás con la confianza y las habilidades necesarias para resolver problemas prácticos con SQL y mejorar tu proceso de desarrollo.

En esta sección, aprenderemos a utilizar la sentencia SELECT de SQL para obtener una columna de una tabla, varias columnas de una tabla y todas las columnas de una tabla. También descubriremos cómo devolver valores únicos.

En esta sección, exploraremos cómo organizar y priorizar los datos devueltos por una consulta utilizando la cláusula ORDER BY. Ubicada al final de una instrucción SELECT, esta cláusula permite ordenar los resultados por una o varias columnas, ya sea en orden ascendente o descendente, lo que facilita una salida de datos más significativa y fácil de interpretar.

En esta sección, aprenderemos a filtrar los datos devueltos utilizando la cláusula WHERE de la instrucción SELECT. Aprenderemos a comprobar la igualdad, la desigualdad, los rangos de valores mayores y menores, y los valores NULL.

En esta sección, exploraremos cómo refinar las condiciones de búsqueda combinando cláusulas WHERE con los operadores AND y OR. También cubriremos cómo se puede utilizar el operador NOT para excluir ciertos resultados.

En esta sección, aprenderemos qué son las funciones de agregación en SQL y cómo utilizarlas para resumir los datos de una tabla.

Uso del Operador AND

Solución