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_order(self):
        """Check that the query selects the correct columns in the correct order."""
        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 = ["id", "name", "population", "continent"]
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "Selected columns are exactly id, name, population, continent in correct order.",
            f"Selected columns are {columns}, but expected {expected_columns}."
        )

    def test_filter_north_america(self):
        """Check that only rows with continent 'North America' are returned."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        # continent is the 4th column (index 3)
        all_na = all(row[3] == 'North America' for row in rows)
        _dynamic_test(
            self,
            all_na,
            "All rows have continent 'North America'.",
            "There are rows with continent not equal to 'North America'."
        )

    def test_population_descending(self):
        """Check that the result is ordered by population descending."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        populations = [row[2] for row in rows]
        condition = all(populations[i] >= populations[i+1] for i in range(len(populations)-1))
        _dynamic_test(
            self,
            condition,
            "Population column is sorted in descending order.",
            "Population column is not sorted in descending order."
        )

    def test_expected_rows(self):
        """Check that the correct rows are returned for 'North America'."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        user_rows_set = set(user_rows)
        # Expected rows for 'North America' continent
        expected_rows = [
            (8, 'United States', 278357000, 'North America'),
            (3, 'Mexico ', 98881000, 'North America')
        ]
        # Remove trailing spaces from name for comparison
        expected_rows = [ (r[0], r[1].strip(), r[2], r[3]) for r in expected_rows ]
        user_rows_set = set( (r[0], r[1].strip(), r[2], r[3]) for r in user_rows )
        expected_rows_set = set(expected_rows)
        missing = expected_rows_set - user_rows_set
        extra = user_rows_set - expected_rows_set
        condition = len(missing) == 0 and len(extra) == 0
        msg = ""
        if missing:
            msg += f"Missing rows: {missing}\\n"
        if extra:
            msg += f"Unexpected extra rows: {extra}\\n"
        _dynamic_test(
            self,
            condition,
            "Query returns exactly the expected rows for 'North America'.",
            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):
    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

Ce cours est idéal pour les débutants souhaitant découvrir le monde de SQL. Que vous débutiez dans la gestion de bases de données ou que vous cherchiez à utiliser SQL pour vos projets de développement d'applications, ce cours couvre les notions essentielles. Vous apprendrez rapidement à exploiter tout le potentiel de SQL, de l'interrogation et la gestion des données à son intégration fluide dans des applications concrètes. À la fin du cours, vous disposerez de la confiance et des compétences nécessaires pour résoudre des problèmes pratiques avec SQL et améliorer votre processus de développement.

Dans cette section, nous apprendrons à utiliser l'instruction SQL SELECT pour obtenir une colonne d'une table, plusieurs colonnes d'une table et toutes les colonnes d'une table. Nous découvrirons également comment retourner des valeurs uniques.

Dans cette section, nous examinerons comment organiser et hiérarchiser les données renvoyées par une requête à l'aide de la clause ORDER BY. Placée à la fin d'une instruction SELECT, cette clause permet de trier les résultats selon une ou plusieurs colonnes, en ordre croissant ou décroissant, offrant ainsi une sortie de données plus significative et facilement interprétable.

Dans cette section, nous apprendrons à filtrer les données retournées à l'aide de la clause WHERE de l'instruction SELECT. Nous verrons comment tester l'égalité, l'inégalité, les plages de valeurs supérieures et inférieures, ainsi que les valeurs NULL.

Dans cette section, nous explorerons comment affiner vos conditions de recherche en combinant les clauses WHERE avec les opérateurs AND et OR. Nous aborderons également l'utilisation de l'opérateur NOT pour exclure certains résultats.

Dans cette section, nous allons découvrir ce que sont les fonctions d'agrégation SQL et comment les utiliser pour résumer les données d'une table.

Défi : Tri de la Population en Amérique du Nord

Solution