Summary  
This chapter explains how to retrieve multiple columns from a table by listing their names separated by commas in a SELECT statement.

General domain of usage  
Querying relational databases

## Inspection de la table

Exploration approfondie de la base de données `country`. Cette base de données contient une seule table, également nommée `country`. Analyse des données présentes dans cette table.

Cette table contient **15 lignes**, représentant 15 enregistrements uniques pour différents pays.

La table comprend **7 colonnes** : `id`, `name`, `continent`, `region`, `SurfaceArea`, `capital` et `population`.

1. `id` - identifiant unique pour chaque enregistrement ;

2. `name` - nom du pays ;

3. `continent` - continent où se situe le pays ;

4. `region` - région spécifique au sein du continent ;

5. `SurfaceArea` - superficie totale du pays ;

6. `capital` - capitale du pays ;

7. `population` - nombre d'habitants du pays.



## Syntaxe pour sélectionner plusieurs colonnes

Pour extraire plusieurs colonnes, utilisation de l'instruction `SELECT`. Après `SELECT`, énumération des noms de colonnes à extraire, séparés par des virgules.

La syntaxe est la suivante :

```sql
SELECT column1, column2, column3 
FROM table_name;
```

Voici un exemple de sélection de **trois** colonnes depuis la table `country` :

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_retrieves_correct_columns(self):
        """Check if query retrieves only 'continent' and 'population' columns from 'country'."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0].lower() for desc in self.cursor.description]
        expected_columns = ["continent", "population"]
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "The query retrieves only the 'continent' and 'population' columns in the correct order.",
            f"The query should retrieve only the columns 'continent' and 'population' in order, but got: {columns}."
        )

    def test_query_uses_correct_table(self):
        """Check if query returns the expected number of rows from 'country' table (should be 15)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        condition = len(rows) == 15
        _dynamic_test(
            self,
            condition,
            "The query uses the correct table and returns 15 rows.",
            f"The query should return 15 rows from the 'country' table, but got {len(rows)} rows."
        )

    def test_query_column_separator(self):
        """Check that both columns are selected and separated by a comma in the SELECT clause."""
        with open("query.sql", "r") as file:
            query = file.read().lower().replace("\\n", " ")
        # Find the SELECT ... FROM part
        select_from = query.split("from")[0]
        # Remove SELECT keyword
        select_columns = select_from.replace("select", "").strip()
        # Must contain a comma between 'continent' and 'population'
        has_comma = "," in select_columns
        has_continent = "continent" in select_columns
        has_population = "population" in select_columns
        condition = has_comma and has_continent and has_population
        _dynamic_test(
            self,
            condition,
            "The SELECT clause contains both columns separated by a comma.",
            "The SELECT clause must contain both 'continent' and 'population', separated by a comma."
        )

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

Découvrez les bases de SQL — de l'interrogation des données à leur intégration dans des applications concrètes. Que vous débutiez en gestion de bases de données ou que vous souhaitiez utiliser SQL pour vos projets de développement applicatif, ce cours couvre les fondamentaux. Vous apprendrez rapidement à exploiter tout le potentiel de SQL, de l'interrogation et la gestion des données à leur intégration fluide dans des applications réelles. À la fin du cours, vous aurez la confiance et les 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 SELECT de SQL pour obtenir une colonne de table, plusieurs colonnes de table et toutes les colonnes de 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 facile à interpréter.

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 découvrirons ce que sont les fonctions d'agrégation SQL et comment les utiliser pour résumer les données d'une table.

Récupération de Plusieurs Colonnes

Inspection de la table

Syntaxe pour sélectionner plusieurs colonnes

Solution