Summary  
This chapter covers using the SQL AVG() aggregate function to calculate the mean of a column, both on all rows and on a subset filtered by conditions.

General domain of usage  
Relational database querying and data aggregation

`AVG()` gibt den Durchschnittswert einer bestimmten Spalte zurück.

Siehe das Beispiel:

`AVG()` kann auch auf eine gefilterte Menge von Zeilen angewendet werden, die bestimmte Bedingungen erfüllen. Hier ein Beispiel:

SELECT AVG(population) 
FROM country
WHERE population < 4478500;

import unittest
import psycopg2
import pandas as pd
import decimal

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_avg_surfacearea_correctness(self):
        """Check that the query returns the correct average of the surfacearea column from country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Calculate expected average
        self.cursor.execute("SELECT surfacearea FROM country")
        surfaceareas = [row[0] for row in self.cursor.fetchall() if row[0] is not None]
        expected_avg = sum(surfaceareas) / len(surfaceareas) if surfaceareas else None

        self.cursor.execute(query)
        result = self.cursor.fetchone()[0]
        # Accept float rounding error up to 6 decimals
        if isinstance(result, decimal.Decimal):
            result_float = float(result)
        else:
            result_float = result
        if isinstance(expected_avg, decimal.Decimal):
            expected_avg_float = float(expected_avg)
        else:
            expected_avg_float = expected_avg
        condition = expected_avg is not None and abs(result_float - expected_avg_float) < 1e-6
        _dynamic_test(
            self,
            condition,
            "Query returns the correct average value of surfacearea.",
            f"Expected average: {expected_avg}, but got: {result}."
        )

    def test_query_uses_avg_function(self):
        """Check that the query uses the AVG() function."""
        with open("query.sql", "r") as file:
            query = file.read()
        condition = "avg" in query.lower()
        _dynamic_test(
            self,
            condition,
            "Query uses the AVG() function.",
            "Query does not use the AVG() function."
        )

    def test_query_uses_select(self):
        """Check that the query uses the SELECT statement."""
        with open("query.sql", "r") as file:
            query = file.read()
        condition = query.strip().lower().startswith("select")
        _dynamic_test(
            self,
            condition,
            "Query uses the SELECT statement.",
            "Query does not use the SELECT statement."
        )

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):
    import re
    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

Erkunden Sie die Grundlagen von SQL – von der Abfrage von Daten bis zur Integration in reale Anwendungen. Ob Sie gerade erst mit dem Datenbankmanagement beginnen oder SQL für Ihre Anwendungsentwicklungsprojekte nutzen möchten, dieser Kurs behandelt die wichtigsten Aspekte. Sie lernen schnell, das volle Potenzial von SQL auszuschöpfen, von der Abfrage und Verwaltung von Daten bis zur nahtlosen Integration in reale Anwendungen. Am Ende des Kurses verfügen Sie über das nötige Selbstvertrauen und die Fähigkeiten, um praktische Probleme mit SQL zu lösen und Ihren Entwicklungsprozess zu optimieren.

In diesem Abschnitt lernen wir, wie man mit der SQL-SELECT-Anweisung eine einzelne Tabellenspalte, mehrere Tabellenspalten und alle Tabellenspalten abruft.
Wir erfahren außerdem, wie man eindeutige Werte zurückgibt.

In diesem Abschnitt untersuchen wir, wie die durch eine Abfrage zurückgegebenen Daten mithilfe der ORDER BY-Klausel organisiert und priorisiert werden können. Diese Klausel wird am Ende einer SELECT-Anweisung platziert und ermöglicht es, die Ergebnisse nach einer oder mehreren Spalten entweder in aufsteigender oder absteigender Reihenfolge zu sortieren, was eine aussagekräftigere und leichter interpretierbare Datenausgabe ermöglicht.

In diesem Abschnitt lernen wir, wie man mit der WHERE-Klausel der SELECT-Anweisung zurückgegebene Daten filtert. Es wird gezeigt, wie man auf Gleichheit, Ungleichheit, Wertebereiche mit größer oder kleiner als sowie auf NULL-Werte prüft.

In diesem Abschnitt werden wir untersuchen, wie Sie Ihre Suchbedingungen durch die Kombination von WHERE-Klauseln mit den Operatoren AND und OR verfeinern können. Außerdem behandeln wir, wie der Operator NOT verwendet werden kann, um bestimmte Ergebnisse auszuschließen.

In diesem Abschnitt lernen wir, was SQL-Aggregatfunktionen sind und wie sie verwendet werden, um Tabellendaten zusammenzufassen.

Die AVG()-Funktion

Die AVG()-Funktion

Lösung