Summary  
The MIN() function retrieves the smallest value from a specified column in a dataset.

General domain of usage  
Database querying

`MIN()` - deze functie retourneert de laagste waarde in een bepaalde kolom.

Bekijk het volgende voorbeeld:

Hier retourneert `MIN()` de kleinste waarde van population in de country-tabel.

import unittest
import psycopg2
import pandas as pd

class TestPostgresQuery(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_min_surfacearea_correct_value(self):
        """Check if the query returns the correct minimum surfacearea value from the country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        
        # Get correct minimum value with reference query
        self.cursor.execute("SELECT MIN(surfacearea) FROM country;")
        expected = self.cursor.fetchone()[0]

        # Run user query
        try:
            self.cursor.execute(query)
            result = self.cursor.fetchone()[0]
            condition = result == expected
            fail_msg = f"Expected minimum surfacearea {expected}, but got {result}."
        except Exception as e:
            condition = False
            fail_msg = f"Query failed to execute: {e}"

        _dynamic_test(
            self,
            condition,
            "Query returns correct minimum surfacearea value.",
            fail_msg
        )

    def test_usage_of_min_function(self):
        """Check if the query uses the MIN function."""
        with open("query.sql", "r") as file:
            query = file.read()
        condition = "min" in query.lower()
        _dynamic_test(
            self,
            condition,
            "Query uses the MIN function.",
            "Query does not use the MIN function."
        )

    def test_usage_of_surfacearea_column(self):
        """Check if the query selects the surfacearea column."""
        with open("query.sql", "r") as file:
            query = file.read()
        condition = "surfacearea" in query.lower()
        _dynamic_test(
            self,
            condition,
            "Query selects the surfacearea column.",
            "Query does not select the surfacearea column."
        )

    def test_no_syntax_error(self):
        """Check that the query does not have syntax errors."""
        with open("query.sql", "r") as file:
            query = file.read()
        try:
            self.cursor.execute(query)
            condition = True
            fail_msg = ""
        except Exception as e:
            condition = False
            fail_msg = f"Query raised a syntax error: {e}"
        _dynamic_test(
            self,
            condition,
            "Query executed without syntax errors.",
            fail_msg
        )

    def test_no_invalid_column(self):
        """Check that the query does not reference a non-existing column."""
        with open("query.sql", "r") as file:
            query = file.read()
        try:
            self.cursor.execute(query)
            condition = True
            fail_msg = ""
        except psycopg2.errors.UndefinedColumn:
            condition = False
            fail_msg = "Query references a non-existing column."
        except Exception:
            condition = True  # Only fail on undefined column
            fail_msg = ""
        _dynamic_test(
            self,
            condition,
            "Query does not reference a non-existing column.",
            fail_msg
        )

    def test_no_invalid_table(self):
        """Check that the query does not reference a non-existing table."""
        with open("query.sql", "r") as file:
            query = file.read()
        try:
            self.cursor.execute(query)
            condition = True
            fail_msg = ""
        except psycopg2.errors.UndefinedTable:
            condition = False
            fail_msg = "Query references a non-existing table."
        except Exception:
            condition = True  # Only fail on undefined table
            fail_msg = ""
        _dynamic_test(
            self,
            condition,
            "Query does not reference a non-existing table.",
            fail_msg
        )


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

Deze cursus is ideaal voor beginners die de wereld van SQL willen verkennen. Of je nu net begint met databasebeheer of SQL wilt gebruiken voor applicatieontwikkeling, deze cursus behandelt de basisprincipes. Je leert snel hoe je het volledige potentieel van SQL benut, van het opvragen en beheren van gegevens tot het naadloos integreren ervan in praktijktoepassingen. Aan het einde van de cursus beschik je over het vertrouwen en de vaardigheden om praktische problemen met SQL op te lossen en je ontwikkelingsproces te verbeteren.

In deze sectie leren we hoe we de SQL SELECT-instructie gebruiken om één tabelkolom, meerdere tabelkolommen en alle tabelkolommen op te halen. We ontdekken ook hoe we unieke waarden kunnen retourneren.

In deze sectie onderzoeken we hoe gegevens die door een query worden opgehaald, kunnen worden georganiseerd en geprioriteerd met behulp van de ORDER BY-clausule. Deze clausule, geplaatst aan het einde van een SELECT-instructie, maakt het mogelijk om resultaten te sorteren op één of meerdere kolommen, in oplopende of aflopende volgorde, waardoor de gegevensuitvoer betekenisvoller en beter interpreteerbaar wordt.

In deze sectie leren we hoe we geretourneerde gegevens kunnen filteren met behulp van de WHERE-clausule van de SELECT-instructie. We behandelen het testen op gelijkheid, ongelijkheid, grotere en kleinere waarden, waarde-intervallen en NULL-waarden.

In deze sectie behandelen we hoe u zoekvoorwaarden kunt verfijnen door WHERE-clausules te combineren met de AND- en OR-operatoren. We bespreken ook hoe de NOT-operator kan worden gebruikt om bepaalde resultaten uit te sluiten.

In deze sectie behandelen we wat de SQL-aggregatiefuncties zijn en hoe deze gebruikt kunnen worden om tabelgegevens samen te vatten.

De MIN() Functie

Oplossing

De MIN() Functie

Oplossing