Summary  
This chapter covers using comparison operators (<, ≤, ≠) in WHERE clauses to filter query results based on specified conditions.

General domain of usage  
Database querying

SQL supports a lot of conditional statements.



## Less Than

Let's look at the examples: <br>
This example lists all countries that have a population of **less than** 2424200:

SELECT name, population
FROM country
WHERE population < 2424200;

## Less Than or Equal to

The following example retrieves all countries with a population **less than or equal to** 2424200:

SELECT name, population
FROM country
WHERE population <= 2424200;

## Not Equal

The following example retrieves all non-Asian countries:


SELECT name, continent
FROM country
WHERE continent<>'Asia';

import unittest
import psycopg2
import pandas as pd
import re

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 setUp(self):
        with open("query.sql", "r") as file:
            self.query = file.read()

    def test_columns_and_order(self):
        """Check that the selected columns are correct and in the correct order."""
        self.cursor.execute(self.query)
        columns = [desc[0] for desc in self.cursor.description]
        expected_columns = ["name", "population", "region", "capital"]
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "Columns are correct and in the correct order.",
            f"Columns are incorrect or not in the correct order. Expected: {expected_columns}, Got: {columns}"
        )

    def test_only_southern_europe(self):
        """Check that only rows with region 'Southern Europe' are returned."""
        self.cursor.execute(self.query)
        rows = self.cursor.fetchall()
        idx_region = [desc[0] for desc in self.cursor.description].index("region")
        incorrect_rows = [row for row in rows if normalize_text(str(row[idx_region])) != normalize_text("Southern Europe")]
        condition = len(incorrect_rows) == 0
        _dynamic_test(
            self,
            condition,
            "All rows have region 'Southern Europe'.",
            f"Rows found with region not 'Southern Europe': {incorrect_rows}"
        )

    def test_expected_rows(self):
        """Check that all expected rows for 'Southern Europe' are present."""
        # Prepare solution for expected rows
        solution_query = """
        SELECT name, population, region, capital
        FROM country
        WHERE region='Southern Europe';
        """
        self.cursor.execute(solution_query)
        expected_rows = self.cursor.fetchall()

        self.cursor.execute(self.query)
        user_rows = self.cursor.fetchall()
        # Compare as sets for unordered row comparison
        condition = set(user_rows) == set(expected_rows)
        missing = set(expected_rows) - set(user_rows)
        extra = set(user_rows) - set(expected_rows)
        if not condition:
            failure_msg = f"Missing rows: {missing}\\nExtra rows: {extra}"
        else:
            failure_msg = ""
        _dynamic_test(
            self,
            condition,
            "All expected rows for 'Southern Europe' are present and no extra rows.",
            failure_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

This course is perfect for beginners ready to explore the world of SQL. Whether you're just starting out in database management or aiming to use SQL for your application development projects, this course covers the essentials. You'll quickly learn how to leverage the full potential of SQL, from querying and managing data to seamlessly integrating it into real-world applications. By the end of the course, you'll have the confidence and skills to solve practical problems with SQL and enhance your development process.

The WHERE Clause Operators

Less Than

Less Than or Equal to

Not Equal

解答