Summary  
This chapter covers using the WHERE clause in SELECT statements to filter query results based on specified conditions and the proper placement of ORDER BY after filtering.  

General domain of usage  
Relational database querying

Dans les bases de données, les tables contiennent généralement de grands volumes de données. Cependant, il est fréquent de ne s'intéresser qu'à certaines parties spécifiques des données plutôt qu'à l'ensemble. Pour cela, il est nécessaire de définir les conditions de récupération des données, appelées critères de filtrage.

Les données sont filtrées à l'aide d'une clause `WHERE` qui précise les critères de recherche dans une instruction `SELECT`. La clause `WHERE` apparaît immédiatement après le nom de la table.

Lors de la spécification d'une valeur de type chaîne de caractères, comme un nom de pays, il faut entourer le texte de guillemets simples (`'`).



SELECT name, continent 
FROM country 
WHERE continent= 'Europe';

L'instruction `SELECT` récupère 2 colonnes de la table `country` et retourne uniquement les lignes dont la valeur du continent est `'Europe'`.

### Position de la clause

Lors de l'utilisation des clauses `ORDER BY` et `WHERE`, s'assurer que `ORDER BY` vient après `WHERE`.



SELECT capital, continent 
FROM country 
WHERE continent='Asia'
ORDER BY continent DESC;

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_correct_rows(self):
        """Check that only countries from 'North America' are returned with correct columns."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Run user query
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        df = pd.DataFrame(rows, columns=columns)

        # Solution dataframe
        self.cursor.execute("""
            SELECT id, name, region FROM country WHERE continent='North America';
        """)
        sol_rows = self.cursor.fetchall()
        sol_columns = [desc[0] for desc in self.cursor.description]
        sol_df = pd.DataFrame(sol_rows, columns=sol_columns)

        # Check matching rows and shape
        condition = df.shape == sol_df.shape and df.equals(sol_df)
        _dynamic_test(
            self,
            condition,
            "Query returns only the correct rows from 'North America' with correct columns.",
            f"Query did not return the correct rows or columns for 'North America'. Expected:\\n{sol_df}\\nGot:\\n{df}"
        )

    def test_column_order_and_names(self):
        """Check that columns are exactly id, name, region (in this 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 = ["id", "name", "region"]
        condition = columns == expected
        _dynamic_test(
            self,
            condition,
            "Columns are in the correct order: id, name, region.",
            f"Columns are not in the correct order. Expected: {expected}, Got: {columns}"
        )

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 : Utilisation de la clause WHERE

Position de la clause

Défi : Utilisation de la clause WHERE

Position de la clause

Solution