Summary  
This chapter covers using the NOT operator to negate filter conditions in queries, enabling exclusion of records that meet specific criteria.

General domain of usage  
Database querying

In order to **cancel** the condition, you need to use the keyword `NOT`. 

The `NOT` operator is **essential** when you want to **exclude** certain records from your query results. It allows you to specify conditions that should **not** be met, effectively filtering out unwanted data. This can be particularly useful in scenarios where you need to focus on a subset of data that does not meet specific criteria.

First, let's look at the syntax:

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

Now let's look at the example:

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

The `NOT` operator rejects the condition here; hence, it matches the continent to anything that is not Asia.

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

Learn the core fundamentals of SQL and relational databases. Understand how databases store and organize data, write basic SQL queries, work with tables and perform essential operations. Build a strong foundation for working with databases in backend development.

Using the NOT Operator

Solución