In den meisten Datenbanken dient die Spalte `id` als eindeutiger Bezeichner, häufig als **Primärschlüssel** bezeichnet, für jeden Datensatz. Durch die Auswahl sowohl der Spalten `id` als auch `name` kann der eindeutige Bezeichner angezeigt werden, der jedem Land zugeordnet ist. Dies ist entscheidend für die Verknüpfung von Datensätzen oder wenn auf bestimmte Einträge in der Datenbank verwiesen werden muss.

Definition

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_query_returns_id_and_name_columns(self):
        """Check that the query returns both 'id' and 'name' columns."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0].strip().lower() for desc in self.cursor.description]
        has_id = 'id' in columns
        has_name = 'name' in columns
        missing = []
        if not has_id:
            missing.append('id')
        if not has_name:
            missing.append('name')
        _dynamic_test(
            self,
            has_id and has_name,
            "Query returns both 'id' and 'name' columns.",
            f"Query is missing columns: {', '.join(missing)}."
        )

    def test_query_uses_country_table(self):
        """Check that the query selects from the 'country' table."""
        with open("query.sql", "r") as file:
            query = file.read().lower().replace('\\n', ' ')
        uses_country = 'from country' in query
        _dynamic_test(
            self,
            uses_country,
            "Query selects from the 'country' table.",
            "Query does not select from the 'country' table."
        )

    def test_query_returns_expected_rows(self):
        """Check that the query returns all expected (id, name) pairs from the country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Reference solution to get expected rows
        self.cursor.execute("SELECT name, id FROM country")
        expected = set(self.cursor.fetchall())
        self.cursor.execute(query)
        result = set(self.cursor.fetchall())
        condition = expected == result
        if not condition:
            missing = expected - result
            extra = result - expected
            failure_msg = f"Some rows are missing in your query result, or the columns are in a different order."
        else:
            failure_msg = ""
        _dynamic_test(
            self,
            condition,
            "Query returns all correct (name, id) pairs from the country table.",
            failure_msg
        )

    def test_query_syntax_valid(self):
        """Check that the query executes without syntax errors."""
        with open("query.sql", "r") as file:
            query = file.read()
        try:
            self.cursor.execute(query)
            _dynamic_test(
                self,
                True,
                "Query syntax is valid.",
                ""
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "",
                f"Query failed to execute due to syntax error: {e}"
            )

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

Erkunden Sie die Grundlagen von SQL – von der Abfrage von Daten bis zur Integration in reale Anwendungen. Ob Sie gerade erst mit dem Datenbankmanagement beginnen oder SQL für Ihre Anwendungsentwicklungsprojekte nutzen möchten, dieser Kurs behandelt die wichtigsten Aspekte. Sie lernen schnell, das volle Potenzial von SQL auszuschöpfen, von der Abfrage und Verwaltung von Daten bis 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 lernen wir, wie man mit der SQL-SELECT-Anweisung eine einzelne Tabellenspalte, mehrere Tabellenspalten und alle Tabellenspalten abruft.
Wir erfahren außerdem, wie man eindeutige Werte zurückgibt.

In diesem Abschnitt untersuchen wir, wie die durch eine Abfrage zurückgegebenen Daten 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 in aufsteigender oder absteigender Reihenfolge 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. Es wird gezeigt, wie man auf Gleichheit, Ungleichheit, Wertebereiche mit größer oder kleiner als sowie auf NULL-Werte prüft.

In diesem Abschnitt werden wir untersuchen, 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 Operator NOT verwendet werden kann, um bestimmte Ergebnisse auszuschließen.

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

Herausforderung: Alle Länder mit Ihren IDs Finden

Lösung