import unittest
import psycopg2
import pandas as pd

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_columns_and_ordering(self):
        """Check that the query extracts 'region' and 'capital' columns ordered by region, then by capital."""
        with open("query.sql", "r") as file:
            query = file.read()

        # Run user query
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        result_df = pd.DataFrame(rows, columns=columns)

        # Check columns
        expected_columns = ["region", "capital"]
        has_columns = list(result_df.columns) == expected_columns
        _dynamic_test(
            self,
            has_columns,
            "Query returns only 'region' and 'capital' columns in correct order.",
            f"Query must return only columns 'region' and 'capital' in order. Found: {list(result_df.columns)}"
        )

        # Check ordering
        is_ordered = result_df.equals(result_df.sort_values(["region", "capital"], kind="mergesort").reset_index(drop=True))
        _dynamic_test(
            self,
            is_ordered,
            "Rows are sorted by 'region' then by 'capital'.",
            "Rows are not sorted by 'region' then by 'capital'."
        )

    def test_all_rows_present(self):
        """Check that all expected (region, capital) pairs from the table are present in the output."""
        with open("query.sql", "r") as file:
            query = file.read()

        # Reference query
        sol_query = """
        SELECT region, capital FROM country
        """
        self.cursor.execute(sol_query)
        sol_rows = self.cursor.fetchall()
        sol_columns = [desc[0] for desc in self.cursor.description]
        sol_df = pd.DataFrame(sol_rows, columns=sol_columns)

        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        result_df = pd.DataFrame(rows, columns=columns)

        # Compare sets of tuples
        expected_set = set(tuple(x) for x in sol_df.values)
        result_set = set(tuple(x) for x in result_df.values)
        missing = expected_set - result_set
        extra = result_set - expected_set
        condition = len(missing) == 0 and len(extra) == 0
        fail_msg = ""
        if missing:
            fail_msg += f"Missing rows: {missing}. "
        if extra:
            fail_msg += f"Unexpected extra rows: {extra}."
        _dynamic_test(
            self,
            condition,
            "All expected (region, capital) pairs are present in the result.",
            fail_msg.strip()
        )

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

Dieser Kurs ist ideal für Anfänger, die bereit sind, die Welt von SQL zu erkunden. Ob Sie gerade erst mit dem Datenbankmanagement beginnen oder SQL für Ihre Anwendungsentwicklungsprojekte nutzen möchten, dieser Kurs behandelt die Grundlagen. Sie lernen schnell, das volle Potenzial von SQL zu nutzen – von der Abfrage und Verwaltung von Daten bis hin zur nahtlosen Integration in reale Anwendungen. Am Ende des Kurses verfügen Sie über das nötige Selbstvertrauen und die Fähigkeiten, um praktische Probleme mit SQL zu lösen und Ihren Entwicklungsprozess zu optimieren.

In diesem Abschnitt erfahren Sie, wie die SQL-SELECT-Anweisung verwendet wird, um eine einzelne Tabellenspalte, mehrere Tabellenspalten und alle Tabellenspalten abzurufen. Zudem wird erläutert, wie eindeutige Werte zurückgegeben werden.

In diesem Abschnitt untersuchen wir, wie Daten, die von einer Abfrage zurückgegeben werden, mithilfe der ORDER BY-Klausel organisiert und priorisiert werden können. Diese Klausel wird am Ende einer SELECT-Anweisung platziert und ermöglicht es, die Ergebnisse nach einer oder mehreren Spalten entweder aufsteigend oder absteigend zu sortieren, was eine aussagekräftigere und leichter interpretierbare Datenausgabe ermöglicht.

In diesem Abschnitt lernen wir, wie man mit der WHERE-Klausel der SELECT-Anweisung zurückgegebene Daten filtert. Wir behandeln das Testen auf Gleichheit, Ungleichheit, Wertebereiche größer und kleiner sowie NULL-Werte.

In diesem Abschnitt untersuchen wir, wie Sie Ihre Suchbedingungen durch die Kombination von WHERE-Klauseln mit den Operatoren AND und OR verfeinern können. Außerdem behandeln wir, wie der NOT-Operator verwendet werden kann, um bestimmte Ergebnisse auszuschließen.

In diesem Abschnitt erfahren Sie, was SQL-Aggregatfunktionen sind und wie sie verwendet werden, um Tabellendaten zusammenzufassen.

Herausforderung: Dual-Sort-Abfrage

Lösung