Summary  
This chapter explains how to detect missing values in SQL by using the WHERE … IS NULL clause in a SELECT statement to filter rows where a column has no value.

General domain of usage  
Database queries

Si une valeur est manquante ou inconnue pour une ligne, elle est stockée comme `NULL`. Pour déterminer si une valeur est `NULL`, il ne suffit pas de vérifier l’égalité. À la place, on utilise la clause `WHERE` avec `IS NULL` dans une instruction `SELECT` pour trouver les lignes où la valeur de la colonne est `NULL`.

La syntaxe correspondante est la suivante :

```sql
SELECT columns
FROM table 
WHERE column_name IS NULL;
```

L’exemple suivant l’illustre :




SELECT name
FROM country
WHERE region IS NULL;

import unittest
import pandas as pd
class TestTask(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        import psycopg2
        cls.connection = psycopg2.connect(
            host="localhost",
            user="agent",
            password="qwerty",
            dbname="testdb",
            sslmode="disable"
        )
        cls.cursor = cls.connection.cursor()

    def test_correct_columns_selected(self):
        """Check that only 'name' and 'capital' columns are selected."""
        with open("query.sql", "r") as f:
            user_query = f.read()
        self.cursor.execute(user_query)
        columns = [desc[0] for desc in self.cursor.description]
        expected_cols = ["name", "capital"]
        condition = columns == expected_cols
        _dynamic_test(
            self,
            condition,
            "Query selects only 'name' and 'capital' columns.",
            f"Query columns are {columns}, expected {expected_cols}."
        )

    def test_returns_only_null_population(self):
        """Check that only rows with population IS NULL are returned."""
        with open("query.sql", "r") as f:
            user_query = f.read()
        self.cursor.execute(user_query)
        rows = self.cursor.fetchall()
        if not rows:
            # No results, so nothing with NULL population
            condition = True
        else:
            # Check that every returned row corresponds to a country with population IS NULL
            for row in rows:
                name, capital = row
                self.cursor.execute(
                    "SELECT population FROM country WHERE name = %s AND capital = %s",
                    (name, capital)
                )
                pop = self.cursor.fetchone()
                if pop is None or pop[0] is not None:
                    condition = False
                    break
            else:
                condition = True
        _dynamic_test(
            self,
            condition,
            "All returned rows have population IS NULL.",
            "Some returned rows do not have population IS NULL."
        )

    def test_expected_rows_present(self):
        """Check that all expected countries with NULL population are present."""
        # Get expected rows
        self.cursor.execute(
            "SELECT name, capital FROM country WHERE population IS NULL ORDER BY name, capital"
        )
        expected = self.cursor.fetchall()
        # Get user rows
        with open("query.sql", "r") as f:
            user_query = f.read()
        self.cursor.execute(user_query)
        user_rows = self.cursor.fetchall()
        # Compare as sets of tuples
        expected_set = set(expected)
        user_set = set(user_rows)
        missing = expected_set - user_set
        extra = user_set - expected_set
        condition = (missing == set())
        fail_msg = ""
        if missing:
            fail_msg += f"Missing expected rows: {missing}. "
        if extra:
            fail_msg += f"Found unexpected rows: {extra}."
        _dynamic_test(
            self,
            condition,
            "All expected rows with NULL population are present.",
            fail_msg.strip()
        )

    def test_query_uses_is_null(self):
        """Check that the query uses 'IS NULL' in the WHERE clause for population."""
        with open("query.sql", "r") as f:
            user_query = f.read().lower().replace("\\n", " ")
        condition = ("where" in user_query and "population" in user_query and "is null" in user_query)
        _dynamic_test(
            self,
            condition,
            "Query uses IS NULL for population in WHERE clause.",
            "Query does not use 'IS NULL' for population in WHERE clause."
        )

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.

Vérification de l'Absence de Valeur

Solution