Summary  
This chapter explains how to apply comparison operators (<, <=, <>) in SQL WHERE clauses to filter query results by specifying conditions on column values.

General domain of usage  
Relational database querying

SQL oferece diversos **operadores** de comparação.



## Menor que

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 que não sã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

Explore os fundamentos do SQL — desde a consulta de dados até a integração em aplicações do mundo real. Seja você iniciante em gerenciamento de bancos de dados ou esteja 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 a consulta e manipulação de dados até a integração eficiente em aplicações reais. 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 descobriremos 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 classificar os resultados por uma ou várias colunas, em ordem crescente ou decrescente, proporcionando uma saída de dados mais significativa e de fácil interpretação.

Nesta seção, aprenderemos como filtrar dados retornados utilizando a cláusula WHERE da instrução SELECT. Serão abordados testes de igualdade, desigualdade, intervalos de valores maiores e menores, além de 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 de agregação 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