Summary
This chapter explains how to use the asterisk (`*`) wildcard in SQL to retrieve all columns from a table in a single query.

General domain of usage
Relational database querying

Au lieu d’énumérer chaque colonne, il est possible d’utiliser l’astérisque `*` pour récupérer toutes les colonnes et toutes les lignes de la table en une seule fois. Cette méthode est particulièrement utile lorsque l’on souhaite afficher l’ensemble des données d’une table sans saisir manuellement chaque nom de colonne. Voici un exemple :

import unittest
import psycopg2
import pandas as pd
import re

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_selects_all_columns_with_asterisk(self):
        """Check that the query uses '*' to select all columns from country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Normalize whitespace and lowercase
        norm_query = normalize_text(query)
        # Check for correct pattern
        condition = (
            'select * from country' in norm_query or
            'select*from country' in norm_query or
            'select *from country' in norm_query or
            'select* from country' in norm_query
        )
        _dynamic_test(
            self,
            condition,
            "Query uses '*' to select all columns from country table.",
            "Query does not use '*' to select all columns from country table."
        )

    def test_query_returns_all_columns(self):
        """Check that the query result returns all 7 columns from country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        result_columns = [desc[0] for desc in self.cursor.description]
        # Get actual columns from country table
        self.cursor.execute("SELECT * FROM country LIMIT 1")
        expected_columns = [desc[0] for desc in self.cursor.description]
        condition = result_columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "Query returns all columns from country table.",
            f"Query does not return all columns. Expected: {expected_columns}, Got: {result_columns}"
        )

    def test_query_returns_all_rows(self):
        """Check that the query returns all rows from the country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        self.cursor.execute("SELECT * FROM country")
        expected_rows = self.cursor.fetchall()
        condition = len(user_rows) == len(expected_rows)
        _dynamic_test(
            self,
            condition,
            "Query returns all rows from country table.",
            f"Query does not return all rows. Expected {len(expected_rows)} rows, got {len(user_rows)} rows."
        )

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

Explorez les bases de SQL, de la récupération et du filtrage des données avec SELECT et WHERE au tri des résultats avec ORDER BY et à leur synthèse à l'aide de fonctions d'agrégation telles que COUNT, AVG et SUM. À travers des exercices pratiques, développez les compétences nécessaires pour interroger des ensembles de données réels en toute confiance.

Découvrez comment extraire une ou plusieurs colonnes, ou l'ensemble des colonnes d'une table à l'aide de l'instruction SELECT en SQL. Apprenez à retourner des lignes distinctes et à limiter le nombre de résultats renvoyés par une requête.

Découvrez comment organiser les résultats de requête à l'aide de la clause ORDER BY. Apprenez à trier les données par une ou plusieurs colonnes et à contrôler le sens du tri en ordre croissant ou décroissant pour un affichage plus clair.



Découvrez comment filtrer les résultats de requête à l'aide de la clause WHERE. Apprenez à tester l'égalité et l'inégalité, à vérifier les valeurs dans une plage et à identifier les valeurs NULL dans vos données.

Découvrez comment affiner vos conditions de recherche en combinant les clauses WHERE avec les opérateurs AND et OR. Apprenez à utiliser l'opérateur NOT pour exclure des résultats spécifiques de votre requête.



Découvrez comment résumer les données d'une table à l'aide des fonctions d'agrégation SQL. Apprenez à calculer les moyennes et les totaux avec AVG et SUM, à compter les lignes avec COUNT, et à identifier les valeurs extrêmes avec MAX et MIN.



Défi : Récupération de Toutes les Colonnes

Solution