Summary  
This chapter introduces the HAVING clause in SQL to filter grouped query results based on aggregate functions after performing a GROUP BY, since WHERE cannot be used with aggregates.  

General domain of usage  
Database reporting and analytics

El sistema de información escolar está siendo revisado para garantizar la consistencia y precisión de los datos.
Como parte de esta revisión, se ha asignado una nueva tarea de análisis de datos.

Durante las verificaciones rutinarias, se descubrió que algunos registros de estudiantes contienen más de una entrada de calificación, aunque el sistema está diseñado para almacenar solo una calificación por estudiante.

Tu tarea es ayudar a identificar estos casos para una revisión interna adicional.

Reflexiona sobre **cómo puedes hacer esto**. Podrías comenzar considerando que puedes hacerlo utilizando una cláusula `WHERE`, y se vería algo así:

SELECT student_surname
FROM student_grades
WHERE COUNT(grade) > 1

Pero, como puedes ver, aparece un <span style="color:red">error</span> que indica que **no se pueden usar funciones de agregación** dentro de una cláusula `WHERE`. Aquí es donde se necesita la cláusula `HAVING`.

Supón que necesitas **obtener los departamentos** donde el **salario promedio** de los empleados es **inferior a $70,000 por año**.
Para lograr esto, será necesario utilizar una función de agregación y la cláusula `HAVING`:

SELECT department
FROM employees
GROUP BY department
HAVING AVG(salary) < 70000

El resultado es un departamento en la respuesta utilizando la cláusula `HAVING`, donde se establece una **condición para la columna** utilizada para agrupar.



**Para utilizar la agregación de datos** dentro de la cláusula `HAVING`, es necesario tener **agrupación de datos en la consulta**. Como en la consulta anterior, agrupamos los datos por la columna `department`.

Nota

A continuación se muestra una sintaxis más generalizada de la cláusula `HAVING` y cuándo es mejor utilizarla:

```sql
SELECT column1, column2 --(optional)
FROM table
GROUP BY column1
HAVING AGG(column_n) --(condition)

-- This will cause an error
```

A continuación, una breve descripción de la **diferencia principal** entre las cláusulas `WHERE` y `HAVING`, y cuándo utilizar cada una:

1. La cláusula `WHERE` se utiliza **antes** de la agregación de datos, mientras que la cláusula `HAVING` se utiliza **después** de la agregación de datos;
2. La cláusula `WHERE` se escribe **antes** de `GROUP BY`, mientras que la cláusula `HAVING` se escribe **después** de `GROUP BY`.

Estas son las **dos diferencias principales** que debes recordar para un uso exitoso de la cláusula `HAVING`. Ahora, vuelve a la tarea que nos dio la escuela.

import unittest
import psycopg2
import pandas as pd

class TestPostgresQuery(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_query_output_is_correct(self):
        """Check if the query returns only surnames of students with more than 1 grade, sorted alphabetically."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Get expected surnames
        solution_query = '''
            SELECT student_surname
            FROM student_grades
            GROUP BY student_surname
            HAVING COUNT(grade) > 1
            ORDER BY student_surname;
        '''
        self.cursor.execute(solution_query)
        expected = [row[0] for row in self.cursor.fetchall()]
        # Get user result
        self.cursor.execute(query)
        result = [row[0] for row in self.cursor.fetchall()]
        condition = result == sorted(expected)
        if not condition:
            failure_msg = f"Query result is incorrect.\\nExpected: {expected}\\nGot: {result}"
        else:
            failure_msg = ""
        _dynamic_test(
            self,
            condition,
            "Query output is correct and sorted alphabetically.",
            failure_msg
        )

    def test_only_one_column(self):
        """Check that only one column (student_surname) is returned."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        condition = columns == ["student_surname"]
        if not condition:
            failure_msg = f"Query columns are incorrect. Expected ['student_surname'], got {columns}."
        else:
            failure_msg = ""
        _dynamic_test(
            self,
            condition,
            "Query returns only 'student_surname' column.",
            failure_msg
        )

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)


test_solution.py

Este curso es ideal para quienes ya poseen conocimientos básicos de SQL y desean profundizar en conceptos avanzados para crear consultas más potentes. A lo largo del curso, se familiarizarán con la agrupación de datos y el filtrado de datos agrupados. También aprenderán a trabajar con varias tablas simultáneamente, incluyendo cómo combinarlas. Además, explorarán los diferentes tipos de uniones de tablas y su aplicación práctica.

En esta sección, aprenderá a agrupar y gestionar datos de manera efectiva. Se presentará el operador GROUP BY para la agrupación de datos. Además, aprenderá a filtrar datos agrupados utilizando el operador HAVING.

Aprenderá sobre subconsultas anidadas, cómo crearlas y cómo utilizarlas de manera efectiva.

Aquí aprenderá cómo combinar varias tablas, lo que le permitirá trabajar con una tabla unificada y simplificar la creación de consultas.

Aprende los fundamentos del Lenguaje de Definición de Datos (DDL) y del Lenguaje de Manipulación de Datos (DML) en SQL, incluyendo cómo crear, modificar y eliminar objetos de base de datos, así como insertar, actualizar y eliminar datos dentro de las tablas.

Cláusula Having

Instrucciones breves

Solución