You are about to tackle a practical scenario where **subqueries** help you analyze salary data across departments. Imagine a company wants to know which departments pay above the company-wide average salary. To solve this, you will need to compare each department's average salary with the overall average salary for all employees. This challenge will deepen your understanding of **subqueries** for comparative analysis in SQL.

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_correct_departments_returned(self):
        """Check if only departments with above-average salaries are returned."""
        with open("query.sql", "r") as file:
            query = file.read()

        # Calculate company-wide average salary
        self.cursor.execute("SELECT AVG(salary) FROM employees;")
        company_avg = float(self.cursor.fetchone()[0])

        # Get department average salaries
        self.cursor.execute("""
            SELECT d.name, AVG(e.salary) as avg_salary
            FROM departments d
            JOIN employees e ON d.department_id = e.department_id
            GROUP BY d.department_id, d.name
        """)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        dept_avg_df = pd.DataFrame(rows, columns=columns)

        # Departments with avg_salary > company_avg
        expected_names = set(dept_avg_df[dept_avg_df['avg_salary'] > company_avg]['name'])

        # Run user query
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        user_names = set([row[0] for row in user_rows])

        condition = user_names == expected_names
        _dynamic_test(
            self,
            condition,
            "Returned departments match those with above-average salaries.",
            f"Expected departments: {sorted(expected_names)}, but got: {sorted(user_names)}."
        )

    def test_query_uses_subquery(self):
        """Check that the query uses a subquery to calculate the company-wide average salary."""
        with open("query.sql", "r") as file:
            query = file.read().lower().replace('\\n', ' ')
        subquery_found = "select avg(" in query and "from employees" in query
        _dynamic_test(
            self,
            subquery_found,
            "Query uses a subquery to calculate overall average salary.",
            "Query does not use a subquery to calculate overall average salary."
        )

    def test_grouping_by_department(self):
        """Check that the query groups results by department."""
        with open("query.sql", "r") as file:
            query = file.read().lower().replace('\\n', ' ')
        group_by_found = "group by" in query and ("department_id" in query or "d.name" in query or "departments.name" in query)
        _dynamic_test(
            self,
            group_by_found,
            "Query groups by department.",
            "Query does not group by department."
        )

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

Master the art of writing and applying subqueries in SQL through real-world scenarios. This course covers the theory and practice of subqueries, including their use in SELECT, WHERE, and FROM clauses, as well as correlated subqueries. Each section features a unique dataset and practical challenges to reinforce your learning.

Explore subqueries using an e-commerce dataset, focusing on orders, customers, and products. Learn to extract insights and solve business problems using subqueries.

Apply subqueries to HR data, including employees, departments, and salaries. Tackle real-world HR analytics tasks.

Use subqueries to solve problems in a library management system, including books, members, and borrowings.

Challenge: Departments with Above-average Salaries

Ratkaisu

Challenge: Departments with Above-average Salaries

Ratkaisu