Summary  
This chapter introduces SQL comparison operators in the WHERE clause—such as =, <>, <, <=, >, >=, BETWEEN, and IS NULL—to precisely filter query results based on conditional criteria.  

General domain of usage  
Relational database querying

This video introduces SQL conditional statements with a focus on the WHERE clause operators. You will learn how to use operators such as equals (`=`), not equal (`<>`), less than (`<`), less than or equal to (`<=`), and others to filter data in SQL queries. The video demonstrates practical examples using the `country` table, showing how to retrieve records based on population size and region. By the end, you will understand how to use WHERE clause operators to extract exactly the data you need from a database.

SQL oferece suporte a várias declarações condicionais.



## Menor que

Veja os exemplos: <br>
Este exemplo lista todos os países que possuem uma população **menor que** 2424200:

SELECT name, population
FROM country
WHERE population < 2424200;

## Menor ou Igual a

O exemplo a seguir recupera todos os países com população **menor ou igual a** 2424200:

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

## Diferente de

O exemplo a seguir recupera todos os países não asiáticos:


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

Este curso é ideal para iniciantes que desejam explorar o mundo do SQL. Seja você alguém começando em gerenciamento de bancos de dados ou buscando utilizar SQL em projetos de desenvolvimento de aplicações, este curso aborda os conceitos essenciais. Você aprenderá rapidamente a aproveitar todo o potencial do SQL, desde consultas e gerenciamento de dados até a integração eficiente em aplicações do mundo real. Ao final do curso, você terá confiança e habilidades para resolver problemas práticos com SQL e aprimorar seu processo de desenvolvimento.

Nesta seção, aprenderemos como utilizar a instrução SELECT do SQL para obter uma coluna de tabela, múltiplas colunas de tabela e todas as colunas de tabela. Também veremos como retornar valores exclusivos.

Nesta seção, exploraremos como organizar e priorizar os dados retornados por uma consulta utilizando a cláusula ORDER BY. Inserida ao final de uma instrução SELECT, essa cláusula permite ordenar os resultados por uma ou várias colunas, em ordem ascendente ou descendente, proporcionando uma saída de dados mais significativa e de fácil interpretação.

Nesta seção, aprenderemos como filtrar os dados retornados utilizando a cláusula WHERE da instrução SELECT. Aprenderemos a testar igualdade, desigualdade, valores maiores e menores dentro de intervalos, e valores NULL.

Nesta seção, exploraremos como refinar suas condições de busca combinando cláusulas WHERE com os operadores AND e OR. Também abordaremos como o operador NOT pode ser utilizado para excluir determinados resultados.

Nesta seção, aprenderemos o que são as funções agregadas do SQL e como utilizá-las para resumir dados de tabelas.

Os Operadores da Cláusula WHERE

Menor que

Menor ou Igual a

Diferente de

Solução