Summary
Demonstrates how to filter query results by using the SQL BETWEEN operator to check if a column’s value falls within a specified range.

General domain of usage
Database querying

For å sjekke et verdiområde, brukes operatoren `BETWEEN`. Denne operatoren krever to verdier: **startverdi** og **sluttverdi** for området. Nøkkelordet `AND` skal plasseres **mellom** disse verdiene.

Her er syntaksen for å bruke `BETWEEN`-operatoren:

```sql
SELECT columns 
FROM table 
WHERE column BETWEEN value_from AND value_to;
```

Her er et eksempel:

SELECT name, population
FROM country
WHERE population BETWEEN 100000 AND 3000000;

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_correct_columns_selected(self):
        """Check that only name, capital, and population columns are selected and in correct 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_columns = ["name", "capital", "population"]
        _dynamic_test(
            self,
            columns == expected_columns,
            "Correct columns are selected in the correct order.",
            f"Columns selected are {columns}, expected {expected_columns}."
        )

    def test_between_operator_and_values(self):
        """Check that the query uses BETWEEN with correct values (6000000 and 80000000)."""
        with open("query.sql", "r") as file:
            query = file.read().lower().replace("\\n", " ")
        has_between = "between" in query
        has_6000000 = "6000000" in query
        has_80000000 = "80000000" in query
        condition = has_between and has_6000000 and has_80000000
        _dynamic_test(
            self,
            condition,
            "BETWEEN operator with correct values is used.",
            "Query must use BETWEEN operator with 6000000 and 80000000."
        )

    def test_order_by_capital_ascending(self):
        """Check that the result is ordered by capital ascending."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        if not rows:
            _dynamic_test(
                self,
                False,
                "Result is ordered by capital ascending.",
                "Query result is empty, cannot check ordering."
            )
            return
        capitals = [row[1] for row in rows]
        sorted_capitals = sorted([c for c in capitals if c is not None])
        # Place None at the end if present
        if any(c is None for c in capitals):
            sorted_capitals += [None] * capitals.count(None)
        condition = capitals == sorted_capitals
        _dynamic_test(
            self,
            condition,
            "Result is ordered by capital ascending.",
            f"Result is not ordered by capital ascending: {capitals}"
        )

    def test_correct_rows_selected(self):
        """Check that only countries with population between 6000000 and 80000000 are returned."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        # The population column is at index 2
        for row in rows:
            population = row[2]
            condition = population is not None and 6000000 <= population <= 80000000
            if not condition:
                _dynamic_test(
                    self,
                    False,
                    "All rows have population between 6000000 and 80000000.",
                    f"Row with population {population} is not in the required range."
                )
                return
        _dynamic_test(
            self,
            True,
            "All rows have population between 6000000 and 80000000.",
            "Some rows have population outside the required range."
        )

    def test_query_syntax(self):
        """Check that the query executes without syntax errors."""
        with open("query.sql", "r") as file:
            query = file.read()
        try:
            self.cursor.execute(query)
            _dynamic_test(
                self,
                True,
                "Query executes without syntax errors.",
                "Query has a syntax error."
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "Query executes without syntax errors.",
                f"Query has a syntax error: {e}"
            )

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: Kontrollere et Verdiområde

Utfordring: Kontrollere et Verdiområde

Løsning