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_count_europe_and_asia(self):
        """Check that the query counts countries from Europe and Asia only."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        result = self.cursor.fetchone()
        # Count how many countries are in Europe or Asia in the provided data
        self.cursor.execute("SELECT COUNT(*) FROM country WHERE continent='Europe' OR continent='Asia';")
        expected = self.cursor.fetchone()[0]
        actual = result[0] if result else None
        _dynamic_test(
            self,
            actual == expected,
            f"Correctly counted the number of countries in Europe and Asia: {expected}.",
            f"Incorrect count for countries in Europe and Asia. Expected {expected}, got {actual}."
        )

    def test_no_other_continents_included(self):
        """Check that only Europe and Asia countries are counted (not others)."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Get the ids of countries counted by user query
        self.cursor.execute(f"SELECT id FROM country WHERE continent='Europe' OR continent='Asia';")
        valid_ids = set(row[0] for row in self.cursor.fetchall())
        # Confirm that the user query does not count more than these
        # We'll check the total count from the user query
        self.cursor.execute(query)
        user_count = self.cursor.fetchone()[0]
        # Now, check if the count for all countries is higher
        self.cursor.execute("SELECT COUNT(*) FROM country;")
        total_count = self.cursor.fetchone()[0]
        condition = user_count <= len(valid_ids) and user_count != total_count
        _dynamic_test(
            self,
            condition,
            "Query only includes countries from Europe and Asia.",
            "Query may be including countries from other continents."
        )

    def test_query_returns_single_value(self):
        """Check that the query returns exactly one row and one column."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        condition = len(rows) == 1 and len(rows[0]) == 1
        _dynamic_test(
            self,
            condition,
            "Query returns exactly one row and one column.",
            f"Query should return a single value, got {len(rows)} rows and {len(rows[0]) if rows else 0} columns."
        )

    def test_count_is_correct_value(self):
        """Check that the returned count is correct for the current data."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Get expected count directly from the database
        self.cursor.execute("SELECT COUNT(*) FROM country WHERE continent='Europe' OR continent='Asia';")
        expected = self.cursor.fetchone()[0]
        self.cursor.execute(query)
        result = self.cursor.fetchone()
        actual = result[0] if result else None
        _dynamic_test(
            self,
            actual == expected,
            f"Returned count is correct: {expected}.",
            f"Returned count is incorrect. Expected {expected}, got {actual}."
        )

    def test_count_changes_if_data_changes(self):
        """Check that the count changes if a new Europe country is inserted."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Get current count
        self.cursor.execute("SELECT COUNT(*) FROM country WHERE continent='Europe' OR continent='Asia';")
        before_insert = self.cursor.fetchone()[0]
        # Insert a new Europe country
        self.cursor.execute("INSERT INTO country (id, name, continent, Region, SurfaceArea, Capital, Population) VALUES (100, 'Testland', 'Europe', 'Test Region', 123, 'Testville', 1000);")
        self.connection.commit()
        try:
            self.cursor.execute(query)
            result = self.cursor.fetchone()
            after_insert = result[0] if result else None
        finally:
            self.cursor.execute("DELETE FROM country WHERE id=100;")
            self.connection.commit()
        _dynamic_test(
            self,
            after_insert == before_insert + 1,
            "Query dynamically counts new Europe country.",
            f"Query did not count new Europe country. Expected {before_insert + 1}, got {after_insert}."
        )

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

Tämä kurssi sopii erinomaisesti aloittelijoille, jotka haluavat tutustua SQL:n maailmaan. Olitpa sitten vasta aloittamassa tietokantojen hallintaa tai tähtäämässä SQL:n käyttöön sovelluskehitysprojekteissa, kurssi kattaa olennaiset perusteet. Opit nopeasti hyödyntämään SQL:n koko potentiaalia aina tietojen kyselystä ja hallinnasta niiden saumattomaan integrointiin käytännön sovelluksiin. Kurssin lopussa hallitset käytännön ongelmien ratkaisun SQL:llä ja kehitysprosessisi tehostuu.

Tässä osiossa opimme käyttämään SQL SELECT -lausetta yksittäisen taulukon sarakkeen, useiden taulukon sarakkeiden ja kaikkien taulukon sarakkeiden hakemiseen. Lisäksi selvitämme, miten palautetaan yksilölliset arvot.

Tässä osiossa perehdytään siihen, miten kyselyn palauttamaa dataa voidaan järjestää ja priorisoida ORDER BY -lauseen avulla. Tämä lause sijoitetaan SELECT-lauseen loppuun ja sen avulla tulokset voidaan lajitella yhden tai useamman sarakkeen perusteella joko nousevaan tai laskevaan järjestykseen, mikä mahdollistaa merkityksellisemmän ja helpommin tulkittavan datan esittämisen.

Tässä osiossa opimme, kuinka palautettua dataa suodatetaan SELECT-lauseen WHERE-ehdon avulla. Opimme testaamaan yhtäsuuruutta, erisuuruutta, suurempia ja pienempiä arvoja sekä NULL-arvoja.

Tässä osiossa tarkastellaan, kuinka hakuehtoja voidaan tarkentaa yhdistämällä WHERE-lausekkeita AND- ja OR-operaattoreiden avulla. Lisäksi käsitellään, miten NOT-operaattoria voidaan käyttää tiettyjen tulosten poissulkemiseen.

Tässä osiossa opimme, mitä SQL:n yhteenvetofunktiot ovat ja miten niitä käytetään taulukoiden tietojen yhteenvedossa.

Haaste: Mantereiden Määrä

Ratkaisu

Haaste: Mantereiden Määrä

Ratkaisu