Summary  
This chapter covers using the SQL WHERE clause with IS NULL to filter rows that contain null values.

General domain of usage  
Relational database querying

Hvis en verdi mangler eller er ukjent for en rad, lagres den som `NULL`. For å finne ut om en verdi er `NULL`, sjekker du ikke bare for likhet. I stedet bruker du `WHERE`-setningen med `IS NULL` i en `SELECT`-spørring for å finne rader der kolonneverdien er `NULL`.

Syntaksen for dette ser slik ut:

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

Følgende eksempel illustrerer dette:




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

Utforsk det grunnleggende i SQL, fra å hente og filtrere data med SELECT og WHERE til å sortere resultater med ORDER BY og oppsummere dem med aggregeringsfunksjoner som COUNT, AVG og SUM. Gjennom praktiske utfordringer bygger du ferdigheter til å utføre spørringer på reelle datasett med trygghet.

Utforsk hvordan du henter én, flere eller alle kolonner fra en tabell ved hjelp av SQL SELECT-setningen. Lær å returnere distinkte rader og begrense antall resultater som returneres av en spørring.

Lær hvordan du organiserer spørringsresultater ved hjelp av ORDER BY-setningen. Forstå hvordan du sorterer data etter én eller flere kolonner, og styr sorteringsretningen med stigende eller synkende rekkefølge for tydeligere resultater.



Utforsk hvordan du kan filtrere spørringsresultater ved hjelp av WHERE-setningen. Lær å teste for likhet og ulikhet, kontrollere verdier mot et intervall, og identifisere NULL-verdier i dataene dine.

Utforsk hvordan du kan forbedre søkekriteriene ved å kombinere WHERE-setninger med AND- og OR-operatorene. Lær å bruke NOT-operatoren for å utelukke spesifikke resultater fra spørringen din.



Utforsk hvordan du kan oppsummere tabelldata ved hjelp av SQL-aggregeringsfunksjoner. Lær å beregne gjennomsnitt og totaler med AVG og SUM, telle rader med COUNT, og finne ytterverdier med MAX og MIN.



Utfordring: Sjekke for Ingen Verdi

Utfordring: Sjekke for Ingen Verdi

Løsning