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

Cuando se desea filtrar resultados utilizando más de una columna, es posible 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 recuperación y filtrado de datos con SELECT y WHERE hasta la ordenación de resultados con ORDER BY y su resumen mediante funciones agregadas como COUNT, AVG y SUM. A través de desafíos prácticos, desarrollarás las habilidades necesarias para consultar conjuntos de datos reales con confianza.

Descubra cómo recuperar una, varias o todas las columnas de una tabla utilizando la sentencia SELECT de SQL. Aprenda a devolver filas distintas y a limitar la cantidad de resultados que retorna una consulta.

Descubra cómo organizar los resultados de las consultas utilizando la cláusula ORDER BY. Aprenda a ordenar datos por una o varias columnas y a controlar la dirección de ordenamiento con orden ascendente o descendente para obtener una salida más clara.



Descubra cómo filtrar los resultados de las consultas utilizando la cláusula WHERE. Aprenda a comprobar la igualdad y la desigualdad, verificar valores dentro de un rango e identificar valores NULL en sus datos.

Descubra cómo refinar sus condiciones de búsqueda combinando cláusulas WHERE con los operadores AND y OR. Aprenda a utilizar el operador NOT para excluir resultados específicos de su consulta.



Descubra cómo resumir datos de tablas utilizando funciones de agregación en SQL. Aprenda a calcular promedios y totales con AVG y SUM, contar filas con COUNT y encontrar valores extremos con MAX y MIN.



Desafío: Uso del Operador AND

Desafío: Uso del Operador AND

Solución