Summary  
This chapter explains how to apply logical negation using the NOT operator to reverse conditions and exclude unwanted records in code queries.

General domain of usage  
Database querying

This video visually demonstrates how to use the NOT operator in SQL queries. You will see how NOT can exclude specific records from query results, focusing on practical examples with the country table. The video walks through the syntax and shows how to write a query that retrieves all countries not located in a certain continent, reinforcing how NOT helps you filter out unwanted data efficiently.

Um eine **Bedingung auszuschließen**, muss das Schlüsselwort `NOT` verwendet werden.

Der Operator `NOT` ist **unerlässlich**, wenn bestimmte Datensätze von den Abfrageergebnissen **ausgeschlossen** werden sollen. Er ermöglicht die Angabe von Bedingungen, die **nicht** erfüllt sein dürfen, und filtert so unerwünschte Daten heraus. Dies ist besonders nützlich, wenn ein Teil der Daten betrachtet werden soll, der bestimmte Kriterien nicht erfüllt.

Zunächst das Syntax-Beispiel:

```sql
SELECT columns
FROM table 
WHERE NOT condition;
```

Im Folgenden ein Beispiel:

SELECT name, capital
FROM country
WHERE NOT continent='Asia';

Der Operator `NOT` negiert hier die Bedingung; daher werden alle Kontinente ausgewählt, die nicht Asien sind.

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_selects_correct_columns_in_order(self):
        """Check that the query selects 'name' and 'capital' columns 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']
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "Query selects 'name' and 'capital' columns in correct order.",
            f"Query does not select the correct columns/order. Got: {columns}"
        )

    def test_excludes_south_america(self):
        """Check that no result row has continent = 'South America'."""
        # Get all countries from solution query
        solution_query = """
        SELECT name, capital FROM country WHERE NOT continent = 'South America';
        """
        self.cursor.execute(solution_query)
        expected_rows = self.cursor.fetchall()
        self.cursor.execute("SELECT name, capital, continent FROM country;")
        all_rows = self.cursor.fetchall()
        # Run user query
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        # Get all countries whose continent is not South America
        self.cursor.execute("SELECT name, capital FROM country WHERE continent = 'South America';")
        south_america_rows = set(self.cursor.fetchall())
        user_rows_set = set(user_rows)
        # Ensure no row in user_rows is from South America
        intersection = user_rows_set.intersection(south_america_rows)
        condition = len(intersection) == 0
        _dynamic_test(
            self,
            condition,
            "Query result does not include any country from 'South America'.",
            f"Query result includes countries from 'South America': {intersection}"
        )

    def test_returns_all_expected_rows(self):
        """Check that all expected rows are present in the result."""
        # Reference solution
        solution_query = "SELECT name, capital FROM country WHERE NOT continent = 'South America';"
        self.cursor.execute(solution_query)
        expected_rows = set(self.cursor.fetchall())
        # User query
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        user_rows = set(self.cursor.fetchall())
        missing = expected_rows - user_rows
        extra = user_rows - expected_rows
        condition = len(missing) == 0 and len(extra) == 0
        msg = "Query returns all and only the expected rows."
        if not condition:
            msg = f"Missing rows: {missing}. Unexpected rows: {extra}."
        _dynamic_test(
            self,
            condition,
            "Query returns all and only the expected rows.",
            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

Dieser Kurs ist ideal für Anfänger, die bereit sind, die Welt von SQL zu erkunden. Egal, ob Sie gerade erst mit dem Datenbankmanagement beginnen oder SQL für Ihre Anwendungsentwicklungsprojekte nutzen möchten, dieser Kurs behandelt die Grundlagen. Sie lernen schnell, das volle Potenzial von SQL auszuschöpfen – von der Abfrage und Verwaltung von Daten bis hin 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 erfahren wir, wie die SQL-SELECT-Anweisung verwendet wird, um eine einzelne Tabellenspalte, mehrere Tabellenspalten und alle Tabellenspalten abzurufen. Außerdem wird erläutert, wie eindeutige Werte zurückgegeben werden.

In diesem Abschnitt untersuchen wir, wie Daten, die von einer Abfrage zurückgegeben werden, 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 aufsteigend oder absteigend zu sortieren, was eine aussagekräftigere und leichter interpretierbare Datenausgabe ermöglicht.

In diesem Abschnitt lernen wir, wie man zurückgegebene Daten mit der WHERE-Klausel der SELECT-Anweisung filtert. Wir behandeln das Testen auf Gleichheit, Ungleichheit, Wertebereiche größer und kleiner sowie NULL-Werte.

In diesem Abschnitt untersuchen wir, 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 NOT-Operator 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.

Verwendung des NOT-Operators

Lösung