In diesem Kapitel werden die Tabellen `employees` und `department` verwendet.



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_columns_are_correct(self):
        """Check that only first_name, last_name, and salary columns are selected."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        expected_columns = set(["first_name", "last_name", "salary"])
        condition = set(columns) == expected_columns
        _dynamic_test(
            self,
            condition,
            "Query returns only first_name, last_name, and salary columns.",
            f"Returned columns are incorrect: {columns}."
        )

    def test_only_non_tech_departments(self):
        """Ensure all returned employees work in non-tech departments."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        result_df = pd.DataFrame(rows, columns=columns)
        # Get all non-tech department names
        self.cursor.execute("SELECT name FROM department WHERE type = 'non-tech'")
        non_tech_departments = set(row[0] for row in self.cursor.fetchall())
        # Get mapping of employee to department
        self.cursor.execute("SELECT first_name, last_name, department FROM employees")
        emp_dept = {(row[0], row[1]): row[2] for row in self.cursor.fetchall()}
        # Check all returned employees are from non-tech departments
        failed = []
        for _, row in result_df.iterrows():
            emp = (row['first_name'], row['last_name'])
            dept = emp_dept.get(emp, None)
            if dept not in non_tech_departments:
                failed.append(emp)
        condition = len(failed) == 0
        fail_msg = "The following employees are not from non-tech departments: " + ", ".join([f"{f[0]} {f[1]}" for f in failed]) if failed else ""
        _dynamic_test(
            self,
            condition,
            "All employees in result are from non-tech departments.",
            fail_msg
        )

    def test_nested_query_filters_non_tech(self):
        """Ensure the nested query restricts to type = 'non-tech' departments."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Check for the presence of type = 'non-tech' in the query
        condition = "type = 'non-tech'" in query
        _dynamic_test(
            self,
            condition,
            "Nested query filters for non-tech departments.",
            "Your query does not filter for non-tech departments in the nested query."
        )

    def test_salary_descending_order(self):
        """Check that results are ordered by salary descending."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        result_df = pd.DataFrame(rows, columns=columns)
        salaries = result_df['salary'].tolist()
        condition = salaries == sorted(salaries, reverse=True)
        _dynamic_test(
            self,
            condition,
            "Results are ordered by salary descending.",
            "Results are not ordered by salary descending."
        )

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):
    import re
    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

Dieser Kurs eignet sich ideal für alle, die bereits über grundlegende SQL-Kenntnisse verfügen und sich mit fortgeschritteneren Konzepten beschäftigen möchten, um leistungsfähigere Abfragen zu erstellen. Im Verlauf des Kurses lernen Sie das Gruppieren von Daten sowie das Filtern gruppierter Daten kennen. Sie erfahren außerdem, wie Sie mit mehreren Tabellen gleichzeitig arbeiten und diese miteinander kombinieren können. Darüber hinaus werden verschiedene Arten von Tabellenverknüpfungen behandelt und deren praktische Anwendung erläutert.

In diesem Abschnitt lernen Sie, wie Sie Daten effektiv gruppieren und verwalten. Wir führen den GROUP BY-Operator zur Gruppierung von Daten ein. Zusätzlich erfahren Sie, wie gruppierte Daten mit dem HAVING-Operator gefiltert werden.

Sie lernen verschachtelte Unterabfragen kennen, deren Erstellung sowie deren effektiven Einsatz.

Hier lernen Sie, wie Sie mehrere Tabellen kombinieren, um mit einer einheitlichen Tabelle zu arbeiten und die Erstellung von Abfragen zu vereinfachen.

Erlernen Sie die Grundlagen der Data Definition Language (DDL) und der Data Manipulation Language (DML) in SQL, einschließlich der Erstellung, Änderung und Löschung von Datenbankobjekten sowie des Einfügens, Aktualisierens und Löschens von Daten in Tabellen.

Herausforderung: Mitarbeitende in Nicht-Technischen Abteilungen

Kurzanleitung

Lösung