SQL

Item 1 - SQL - Definição e Características Gerais

O que é SQL e quais são suas principais características e objetivos?

SQL (Structured Query Language) é uma linguagem padrão utilizada

para gerenciar e manipular bancos de dados relacionais. Seu
principal objetivo é permitir a criação, consulta, atualização e
exclusão de dados em sistemas gerenciadores de banco de dados
(SGBDs).

Características principais:

Linguagem declarativa: o usuário descreve o que deseja fazer, e

o SGBD define como executar.
Baseada em conjuntos: as operações atuam sobre múltiplos
registros ao mesmo tempo.
Dividida em sub-linguagens: DDL, DML, DCL, DTL.
Independente de SGBD específico, mas com variações dialetais
(ex: T-SQL, PL/SQL).
Fortemente baseada em álgebra relacional e cálculo relacional.

Restrições/Observações:

SQL não é case sensitive para comandos (ex: SELECT = select ),

mas pode ser case sensitive para dados dependendo do SGBD.
Apesar de padronizada pelo ANSI/ISO, há diferenças de
implementação entre Oracle, SQL Server, MySQL, PostgreSQL
etc.

Fonte:
Silberschatz, A.; Korth, H.; Sudarshan, S. Sistemas de Banco de
Dados, 6ª ed., Pearson, 2013. Cap. 6 – Linguagem SQL, p. 160-185.
Item 2 - Tipos de Dados - Textual
Quais são os principais tipos de dados textuais em SQL e como
utilizá-los corretamente?

Os tipos de dados textuais permitem armazenar cadeias de

caracteres. Os principais são:

CHAR(n) : armazena texto de comprimento fixo (completado com

espaços). Ex: CHAR(10)
VARCHAR(n) : armazena texto de comprimento variável até um
limite. Ex: VARCHAR(100)
TEXT : armazena grandes blocos de texto (varia por SGBD)

Exemplo de sintaxe:

CREATE TABLE cliente (

nome VARCHAR(100),
codigo CHAR(5)
);

Observação: o uso de TEXT pode limitar certas operações (como

indexação) dependendo do SGBD.

Fonte:
Coronel, C.; Morris, S. Database Systems: Design, Implementation, &
Management, Cengage, 2018. Cap. 4 – Data Types, p. 122-124.

Item 3 - Tipos de Dados - Numérico

Quais são os principais tipos de dados numéricos em SQL e quando
usar cada um?

Os tipos numéricos representam valores inteiros ou com casas

decimais.

INT / INTEGER : número inteiro padrão.

 SMALLINT : inteiro pequeno.
BIGINT : inteiro longo.
DECIMAL(p, s) / NUMERIC(p, s) : número decimal com precisão
exata (útil em valores monetários).
FLOAT , REAL , DOUBLE PRECISION : números de ponto flutuante
(menos precisos, maior alcance).

Exemplo:

CREATE TABLE produto (

preco DECIMAL(10,2),
quantidade INT
);

Restrição:
Use DECIMAL em valores financeiros para evitar erros de
arredondamento.

Fonte:
Elmasri, R.; Navathe, S. B. Fundamentals of Database Systems, 7ª
ed., Pearson, 2016. Cap. 4 – Relational Model: Data Types, p. 123-
127.

Item 4 - Tipos de Dados - Binário, Booleano e

Data/Hora
Frente:
Quais os tipos de dados binários, booleanos e de data/hora em SQL
e para que servem?

Verso:

Binário:

BINARY(n) : dados binários de tamanho fixo.

VARBINARY(n) : dados binários de tamanho variável.
 BLOB : objetos binários grandes (imagens, arquivos).

Booleano:

BOOLEAN : assume TRUE , FALSE ou NULL .

Data/Hora:

DATE : armazena apenas data (YYYY-MM-DD).

TIME : armazena apenas hora (HH:MM:SS).
TIMESTAMP : data e hora combinadas.
DATETIME : similar ao TIMESTAMP (varia por SGBD).

Exemplo:

CREATE TABLE eventos (

descricao TEXT,
inicio TIMESTAMP,
ativo BOOLEAN
);

Fonte:
MySQL Documentation. Data Types. Disponível em:
https://dev.mysql.com/doc/refman/8.0/en/data-types.html

Item 5 - Tipos de Dados - Outros

Quais são os tipos de dados "outros" em SQL e exemplos de uso?

Além dos tipos clássicos, alguns SGBDs oferecem tipos

especializados, como:

ENUM : conjunto fixo de valores (MySQL).

SET : múltiplos valores de uma lista (MySQL).
UUID : identificadores universais únicos.
JSON : para armazenar objetos JSON.
XML : armazenamento de dados estruturados em XML.
Exemplo:

CREATE TABLE documento (

id UUID,
conteudo JSON
);

Restrição: tipos como ENUM , SET , JSON e XML não são parte do
padrão SQL ANSI e dependem do suporte do SGBD.

Fonte:
PostgreSQL Documentation – Data Types. Disponível em:
https://www.postgresql.org/docs/current/datatype.html

Deseja que eu continue com a seção de Sub-linguagens (DDL, DML,

DCL, DTL) agora?

Estamos agora na Parte 1 da lista baseada na imagem que você

enviou, especificamente na subseção "Tipos de dados" dentro do
tópico "SQL – Fundamentos".

Estrutura geral da Parte 1:

1. SQL – Fundamentos
[✔️] Definição e Características Gerais
[✔️] Tipos de Dados
[✔️] Textuais ( CHAR , VARCHAR , TEXT )
[✔️] Numéricos ( INT , DECIMAL , FLOAT , etc.)
[✔️] Binário, Booleano e Data/Hora
[✔️] Outros (como ENUM , UUID , JSON , etc.)

A próxima seção dentro da Parte 1, seguindo a imagem, será:

2. SQL – Subdivisões da Linguagem

DDL – Data Definition Language

DML – Data Manipulation Language
 DCL – Data Control Language
DTL / TCL – Transaction Control Language

Se desejar, posso continuar imediatamente com essa parte. Deseja

prosseguir?

Ótimo! Seguimos agora com a Parte 2: Subdivisões da Linguagem

SQL, como representado na imagem. Vamos abordar cada
sublinguagem (DDL, DML, DCL, DTL/TCL) com suas finalidades,
características específicas e comandos típicos com sintaxe
comentada.

2. SQL – Subdivisões da Linguagem

DDL – Data Definition Language

Objetivo: Definir a estrutura do banco de dados (tabelas, colunas,

restrições, etc.).

Principais comandos:

CREATE
DROP
ALTER
TRUNCATE
RENAME

1. CREATE TABLE

CREATE TABLE nome_da_tabela (

id INT PRIMARY KEY,
nome VARCHAR(100) NOT NULL,
idade INT DEFAULT 0
);

Cria uma nova tabela.

 Inclui definições de tipos e restrições (como NOT NULL , DEFAULT ,
PRIMARY KEY ).

2. DROP TABLE

DROP TABLE nome_da_tabela;

Deleta permanentemente uma tabela e seus dados.

Irreversível.

3. ALTER TABLE

ALTER TABLE nome_da_tabela ADD COLUMN email VARCHAR(100);

ALTER TABLE nome_da_tabela DROP COLUMN idade;

Modifica a estrutura da tabela (adiciona, remove, ou altera

colunas).

4. TRUNCATE TABLE

TRUNCATE TABLE nome_da_tabela;

Remove todos os registros da tabela sem apagar a estrutura.

Mais rápido que DELETE sem WHERE .

5. RENAME TABLE

RENAME TABLE nome_antigo TO novo_nome;

Altera o nome da tabela.

DML – Data Manipulation Language

Objetivo: Manipular dados dentro das tabelas.

Principais comandos:
 INSERT
UPDATE
DELETE
SELECT

1. INSERT INTO

INSERT INTO nome_da_tabela (coluna1, coluna2)

VALUES ('valor1', 'valor2');

Insere um novo registro.

2. UPDATE

UPDATE nome_da_tabela
SET coluna1 = 'novo_valor'
WHERE id = 1;

Atualiza um ou mais registros.

3. DELETE

DELETE FROM nome_da_tabela

WHERE id = 1;

Remove registros específicos.

4. SELECT

SELECT * FROM nome_da_tabela;

Recupera registros.
Pode usar WHERE , JOIN , GROUP BY , HAVING , ORDER BY , LIMIT .

DCL – Data Control Language

Objetivo: Controle de permissões e segurança no banco.

Comandos:

GRANT
REVOKE

1. GRANT

GRANT SELECT, INSERT ON nome_da_tabela TO usuario;

Concede permissões.

2. REVOKE

REVOKE SELECT, INSERT ON nome_da_tabela FROM usuario;

Revoga permissões.

TCL (às vezes referida como DTL na imagem) – Transaction Control Language

Objetivo: Controle de transações para garantir integridade dos

dados.

Comandos:

COMMIT
ROLLBACK

1. COMMIT

COMMIT;

Confirma definitivamente todas as alterações feitas durante a

transação.

2. ROLLBACK
 ROLLBACK;

Cancela todas as alterações feitas desde o último COMMIT .

3. BEGIN / START TRANSACTION

START TRANSACTION;
-- comandos DML
COMMIT;

Inicia uma transação explicitamente.

Com isso, completamos a Parte 2 da sua imagem.

A próxima será a Parte 3: Restrições de Integridade ( NOT NULL ,

UNIQUE , PRIMARY KEY , FOREIGN KEY , CHECK , DEFAULT ).

Posso avançar para ela?

Perfeito! Avançando para a Parte 3: Restrições de Integridade,

também chamadas de constraints em SQL. Elas garantem a
correção, coerência e confiabilidade dos dados nas tabelas.

3. SQL – Restrições de Integridade

Essas restrições são definidas geralmente junto com a criação da

tabela ( CREATE TABLE ) ou posteriormente via ALTER TABLE .

1. NOT NULL

Garante que o valor de uma coluna não poderá ser nulo.

Sintaxe:

CREATE TABLE funcionarios (

id INT NOT NULL,
nome VARCHAR(100) NOT NULL
);
Comentário:
Evita omissão de dados obrigatórios.

2. UNIQUE

Garante que os valores da coluna sejam exclusivos (sem

repetições).

Sintaxe:

CREATE TABLE clientes (

id INT PRIMARY KEY,
cpf VARCHAR(11) UNIQUE
);

Comentário:
Permite NULL por padrão (exceto em algumas variações de SGBD
como Oracle).

3. PRIMARY KEY

Identifica de forma única cada linha da tabela.

Implica automaticamente NOT NULL e UNIQUE .

Sintaxe:

CREATE TABLE produtos (

codigo INT PRIMARY KEY,
nome VARCHAR(50)
);

Composta:

CREATE TABLE vendas (

produto_id INT,
cliente_id INT,
PRIMARY KEY (produto_id, cliente_id)
);
4. FOREIGN KEY

Garante relacionamento entre tabelas.

Cria uma dependência referencial com a PRIMARY KEY de outra
tabela.

Sintaxe:

CREATE TABLE pedidos (

id INT PRIMARY KEY,
cliente_id INT,
FOREIGN KEY (cliente_id) REFERENCES clientes(id)
);

Com opções:

FOREIGN KEY (cliente_id) REFERENCES clientes(id)

ON DELETE CASCADE
ON UPDATE CASCADE;

5. CHECK

Impõe uma regra de validação para valores da coluna.

Sintaxe:

CREATE TABLE funcionarios (

idade INT CHECK (idade >= 18)
);

Comentário:
Nem todos os SGBDs aplicam CHECK da mesma forma (ex: MySQL
até versões recentes o ignorava).

6. DEFAULT

Define um valor padrão para a coluna, caso nenhum valor seja

inserido.
Sintaxe:

CREATE TABLE produtos (

nome VARCHAR(100),
estoque INT DEFAULT 0
);

Resumo das restrições:

Restrição Garante o quê?

NOT NULL Campo obrigatório

UNIQUE Valores únicos (sem repetições)
PRIMARY KEY Identificador único + obrigatoriedade ( NOT NULL )
FOREIGN KEY Integração/relacionamento com outra tabela
CHECK Regras de negócio simples (faixa de valores etc.)
DEFAULT Valor usado automaticamente se omitido pelo usuário

Finalizamos a Parte 3: Restrições de Integridade.

Deseja que eu continue para a Parte 4: Operadores e Comandos

Especiais do SELECT (como * , DISTINCT , AS , FROM , JOIN , WHERE ,
etc.)?

Ótimo. Vamos agora para a Parte 4: Operadores e Comandos

Especiais da cláusula SELECT , essenciais para consultas eficientes
no SQL. Essa parte da imagem foca nos elementos que permitem
recuperar, formatar, filtrar e combinar dados.

4. SQL – Operadores e Comandos do SELECT

1. SELECT * (todos os campos)

SELECT * FROM funcionarios;

Recupera todas as colunas de todos os registros da tabela.

2. SELECT colunas específicas

SELECT nome, cargo FROM funcionarios;

Recupera apenas as colunas selecionadas.

3. DISTINCT

SELECT DISTINCT cargo FROM funcionarios;

Elimina valores duplicados da coluna ou colunas indicadas.

Muito útil para listas únicas.

4. AS (alias – apelido para colunas ou tabelas)

SELECT nome AS funcionario_nome FROM funcionarios;

Renomeia a coluna ou tabela no resultado da consulta.

Não altera o nome real no banco.

5. FROM

SELECT nome FROM funcionarios;

Indica de qual tabela os dados devem ser lidos.

Sempre obrigatória (exceto em comandos de funções do
sistema).

6. JOIN (junções entre tabelas)

INNER JOIN (interseção):

SELECT f.nome, d.nome AS departamento

FROM funcionarios f
INNER JOIN departamentos d ON f.dept_id = d.id;

LEFT JOIN (todos da esquerda + correspondentes da direita):

 SELECT f.nome, d.nome
FROM funcionarios f
LEFT JOIN departamentos d ON f.dept_id = d.id;

RIGHT JOIN (inverso do LEFT JOIN).

FULL JOIN (todos os registros de ambas as tabelas).

7. WHERE

SELECT nome FROM funcionarios

WHERE idade > 30 AND cargo = 'Analista';

Aplica filtros com expressões lógicas ( = , < , > , LIKE , IN ,

BETWEEN , IS NULL ...).

8. GROUP BY

SELECT cargo, COUNT(*) FROM funcionarios

GROUP BY cargo;

Agrupa resultados com base em uma ou mais colunas.

9. HAVING

SELECT cargo, COUNT(*) FROM funcionarios

GROUP BY cargo
HAVING COUNT(*) > 2;

Aplica filtros após o agrupamento ( WHERE → antes, HAVING →

depois).

10. ORDER BY

SELECT nome, idade FROM funcionarios

ORDER BY idade DESC;

Ordena os resultados por uma ou mais colunas.

 Padrão: ASC (crescente); DESC para decrescente.

11. LIMIT (ou FETCH FIRST)

SELECT * FROM funcionarios

LIMIT 5;

Limita a quantidade de resultados retornados.

Em Oracle usa-se FETCH FIRST n ROWS ONLY (a partir da versão 12c).

Observações Finais:

A cláusula SELECT pode incluir várias dessas partes em

sequência:

SELECT nome AS funcionario, cargo

FROM funcionarios
WHERE idade > 25
GROUP BY cargo
HAVING COUNT(*) > 1
ORDER BY nome
LIMIT 10;

Com isso, finalizamos a Parte 4 da imagem.

Deseja que avancemos agora para a Parte 5: Operadores de

Comparação e Lógicos no WHERE ( = , > , IN , BETWEEN , LIKE , IS
NULL , AND , OR , NOT , etc.)?

Perfeito. A seguir, a Parte 5: Operadores de Comparação e Lógicos

usados com a cláusula WHERE , fundamentais para filtrar resultados
com precisão em consultas SQL.

5. SQL – Operadores de Comparação e Lógicos com WHERE

Esses operadores definem condições para seleção de registros.

1. = (Igualdade)

SELECT * FROM funcionarios

WHERE cargo = 'Gerente';

Compara igualdade exata.

2. <> ou != (Diferente)

WHERE salario <> 2000;

Retorna registros com valor diferente de 2000.

O padrão ANSI é <> ; != é aceito em muitos SGBDs (como
MySQL, SQL Server).

3. > (Maior que), < (Menor que), >= , <=

WHERE idade >= 30;

Operadores numéricos comuns.

4. BETWEEN

WHERE idade BETWEEN 30 AND 40;

Inclusivo: equivale a idade >= 30 AND idade <= 40 .

5. IN

WHERE cargo IN ('Gerente', 'Analista', 'Estagiário');

Verifica se o valor está dentro de uma lista explícita.

6. LIKE (pesquisa textual com curingas)

WHERE nome LIKE 'Jo%'; -- começa com 'Jo'

WHERE nome LIKE '%ana%'; -- contém 'ana'
 % representa qualquer sequência de caracteres.
_ representa um único caractere.

7. IS NULL / IS NOT NULL

WHERE telefone IS NULL;

WHERE telefone IS NOT NULL;

Usado para verificar valores nulos, pois = NULL não funciona.

8. AND , OR , NOT (Lógicos)

WHERE idade > 30 AND cargo = 'Analista';

WHERE nome LIKE 'A%' OR cargo = 'Gerente';
WHERE NOT salario BETWEEN 2000 AND 4000;

AND : todas as condições devem ser verdadeiras.

OR : ao menos uma deve ser verdadeira.
NOT : inverte a condição.

9. Agrupamento com Parênteses

WHERE (cargo = 'Analista' OR cargo = 'Gerente')

AND idade < 40;

Parênteses são usados para controlar a precedência lógica,

semelhante à matemática.

Resumo – Operadores e Exemplo Prático

Tipo Operadores/Palavras-chave Exemplo

Comparação = , <> , != , < , > , <= salario >= 3000

Intervalo BETWEEN , IN idade BETWEEN 25 AND 40

Texto LIKE , IS NULL nome LIKE 'Jo%'

Lógicos AND , OR , NOT cargo = 'Gerente' OR idade < 30

Encerramos a Parte 5: Operadores no WHERE .

Vamos à Parte 6: Comandos de Modificação de Dados – INSERT ,

UPDATE e DELETE , responsáveis por inserir, atualizar e remover
registros nas tabelas. Esses comandos compõem o núcleo do DML
(Data Manipulation Language) no SQL.

6. SQL – Comandos de Modificação de Dados (DML)

1. INSERT INTO – Inserção de Dados

Sintaxe completa (colunas explícitas):

INSERT INTO funcionarios (nome, idade, cargo, salario)

VALUES ('João Silva', 35, 'Analista', 4500);

A ordem dos valores deve corresponder à ordem das colunas

listadas.
Não é necessário inserir valores para colunas que aceitam NULL
ou têm DEFAULT .

Inserção sem definir colunas (não recomendado):

INSERT INTO funcionarios

VALUES ('João Silva', 35, 'Analista', 4500);

A ordem deve ser exatamente a da tabela, o que é arriscado em

alterações futuras.

2. UPDATE – Atualização de Registros

UPDATE funcionarios
SET salario = 5000, cargo = 'Senior'
WHERE id = 4;

Atualiza um ou mais campos em registros existentes.

Obrigatório usar WHERE , caso contrário todos os registros serão
alterados.
3. DELETE – Exclusão de Registros

DELETE FROM funcionarios

WHERE cargo = 'Estagiário';

Remove registros com base em condição.

Assim como no UPDATE , omitindo o WHERE apaga todos os dados
da tabela:

DELETE FROM funcionarios; -- PERIGOSO

Observações Importantes sobre DML

Comando Função Riscos comuns

INSERT Adiciona novos registros Valores fora de ordem ou inválidos

UPDATE Modifica registros existentes Falta de WHERE altera tudo
DELETE Remove registros Sem WHERE , exclui tudo

Transações e Segurança

É possível usar transações para evitar perda acidental de dados:

BEGIN TRANSACTION;

UPDATE funcionarios SET salario = 8000 WHERE id = 10;

ROLLBACK; -- desfaz a alteração

-- COMMIT; -- confirma a alteração

Em bancos como PostgreSQL, Oracle e SQL Server, o uso de

transações ajuda na integridade.

7. SQL – Funções de Agregação (COUNT, SUM, AVG, MAX, MIN)

As funções de agregação são utilizadas para realizar cálculos em
colunas numéricas e retornar um único resultado (um valor escalar
agregado), muitas vezes combinadas com GROUP BY .

1. COUNT() – Contagem de registros

SELECT COUNT(*) FROM funcionarios;

SELECT COUNT(salario) FROM funcionarios;

COUNT(*) : conta todas as linhas, inclusive com valores NULL .

COUNT(campo) : conta apenas as linhas com valor não nulo no
campo indicado.

2. SUM() – Soma

SELECT SUM(salario) FROM funcionarios;

Soma todos os valores numéricos de uma coluna.

Ignora valores NULL .

3. AVG() – Média Aritmética

SELECT AVG(salario) FROM funcionarios;

Retorna a média aritmética dos valores não nulos.

4. MAX() e MIN() – Maior e menor valor

SELECT MAX(salario) FROM funcionarios;

SELECT MIN(salario) FROM funcionarios;

Retornam respectivamente o maior e o menor valor da coluna.

5. Combinando com GROUP BY

SELECT cargo, COUNT(*) AS total_funcionarios

FROM funcionarios
 GROUP BY cargo;

Agrupa os dados por cargo e retorna a quantidade de

funcionários em cada grupo.

SELECT cargo, AVG(salario) AS media_salario

FROM funcionarios
GROUP BY cargo;

Média dos salários por cargo.

6. Combinando com HAVING (filtro pós-agregação)

SELECT cargo, COUNT(*) AS total

FROM funcionarios
GROUP BY cargo
HAVING COUNT(*) > 5;

Filtra os grupos agregados, diferente do WHERE (que atua linha a

linha).
HAVING é obrigatório se quiser filtrar depois da agregação.

Resumo das Funções

Função Descrição

COUNT() Conta o número de registros

SUM() Soma os valores numéricos
AVG() Calcula a média
MAX() Maior valor
MIN() Menor valor

Encerramos a Parte 7: Funções de Agregação.

Posso seguir para a Parte 8: Agrupamento e Filtragem com GROUP BY

e HAVING (onde aprofundaremos o uso desses dois elementos
essenciais para relatórios e análises)?

8. SQL – Agrupamento e Filtragem com GROUP BY e HAVING

Os comandos GROUP BY e HAVING são usados em conjunto com

funções de agregação para organizar e filtrar conjuntos de registros
agrupados. São fundamentais na geração de relatórios analíticos e
resumos estatísticos.

1. GROUP BY – Agrupar Dados

O GROUP BY serve para agrupar registros por uma ou mais colunas,

permitindo aplicar funções de agregação a cada grupo.

Exemplo: Quantidade de funcionários por cargo

SELECT cargo, COUNT(*) AS total

FROM funcionarios
GROUP BY cargo;

Agrupa os dados por cargo .

Retorna um total por grupo.

Exemplo: Salário médio por departamento

SELECT departamento, AVG(salario) AS media_salarial

FROM funcionarios
GROUP BY departamento;

2. Regras do GROUP BY

Toda coluna no SELECT que não usa uma função de agregação

deve obrigatoriamente aparecer no GROUP BY .

Errado:

SELECT cargo, salario FROM funcionarios GROUP BY cargo;

-- ERRO: coluna "salario" deve aparecer em GROUP BY ou em função
 de agregação

Correto:

SELECT cargo, MAX(salario) FROM funcionarios GROUP BY cargo;

3. HAVING – Filtrar grupos

Enquanto o WHERE filtra linhas antes da agregação, o HAVING filtra os

resultados dos grupos agregados.

Exemplo: Cargos com mais de 5 funcionários

SELECT cargo, COUNT(*) AS total

FROM funcionarios
GROUP BY cargo
HAVING COUNT(*) > 5;

Aplica a condição depois da agregação.

Não funciona com WHERE pois COUNT(*) não está disponível antes
da agregação.

4. Usando GROUP BY com múltiplas colunas

SELECT departamento, cargo, COUNT(*) AS total

FROM funcionarios
GROUP BY departamento, cargo;

Agrupamento hierárquico: primeiro por departamento , depois por

cargo .

5. Combinando WHERE , GROUP BY , HAVING

SELECT departamento, AVG(salario) AS media

FROM funcionarios
WHERE ativo = true
 GROUP BY departamento
HAVING AVG(salario) > 5000;

WHERE : filtra registros antes da agregação (somente ativos).

GROUP BY : agrupa os dados por departamento.
HAVING : filtra os grupos cujo salário médio excede 5000.

Resumo das Diferenças: WHERE vs HAVING

Filtro aplicado em... WHERE HAVING

Antes da agregação ✅ ❌
Depois da agregação ❌ ✅
Pode usar agregação ❌ ✅ (ex: AVG , COUNT )

Com isso, encerramos a Parte 8: Agrupamento e Filtragem com

GROUP BY e HAVING .

Posso avançar para a Parte 9: Cláusula ORDER BY e ordenação

ASC/DESC, onde veremos como ordenar os resultados em SQL?

9. SQL – Cláusula ORDER BY e Ordenação ASC / DESC

A cláusula ORDER BY é usada para ordenar os resultados de uma

consulta SQL com base nos valores de uma ou mais colunas. A
ordenação pode ser crescente ( ASC ) ou decrescente ( DESC ). Esse
comando é crucial em exibições organizadas, relatórios e
dashboards.

1. Sintaxe básica de ORDER BY

SELECT nome, salario

FROM funcionarios
ORDER BY salario;

Por padrão, a ordenação é crescente (ASC).

 Resultado: lista de salários do menor para o maior.

2. Ordenação Descendente ( DESC )

SELECT nome, salario

FROM funcionarios
ORDER BY salario DESC;

Ordena os salários do maior para o menor.

3. Ordenação por múltiplas colunas

SELECT nome, departamento, salario

FROM funcionarios
ORDER BY departamento ASC, salario DESC;

Primeiro ordena por departamento (crescente).

Depois, dentro de cada departamento, ordena salario
(decrescente).

4. Ordenação por colunas não exibidas no SELECT

SELECT nome
FROM funcionarios
ORDER BY salario DESC;

É permitido ordenar por uma coluna mesmo que ela não esteja
visível no resultado.

5. Ordenação por índice da coluna (não recomendada)

SELECT nome, salario

FROM funcionarios
ORDER BY 2 DESC;

ORDER BY 2 ordena pela segunda coluna do SELECT .

Funciona, mas reduz a clareza e legibilidade do código.
6. Combinando com funções de agregação

SELECT cargo, COUNT(*) AS total

FROM funcionarios
GROUP BY cargo
ORDER BY total DESC;

Ordena os cargos do mais numeroso para o menos numeroso.

7. NULLS FIRST / NULLS LAST (dependente do SGBD)

Alguns SGBDs permitem controlar onde os valores NULL aparecem

na ordenação:

SELECT nome, bonus

FROM funcionarios
ORDER BY bonus DESC NULLS LAST;

Garante que NULL apareça no final mesmo com ordenação

decrescente.

Obs: No PostgreSQL essa cláusula é suportada. Em outros, o

comportamento pode variar (ex: Oracle, SQL Server, MySQL têm
comportamentos distintos).

Resumo – ORDER BY

Comando Função

ORDER BY coluna ASC Ordena do menor para o maior (padrão)

ORDER BY coluna DESC Ordena do maior para o menor
ORDER BY col1, col2 Ordena primeiro por col1 , depois por col2
ORDER BY 2 Ordena pela segunda coluna da cláusula SELECT
NULLS FIRST / LAST Controla posição de valores nulos (nem sempre suportado)
Concluímos a Parte 9: Cláusula ORDER BY e ordenação ASC/DESC.

Avançamos agora para a Parte 10: Cláusulas de Junção ( JOIN , INNER

JOIN , LEFT JOIN , RIGHT JOIN , FULL OUTER JOIN )?

10. SQL – Cláusulas de Junção ( JOIN , INNER JOIN , LEFT JOIN , RIGHT
JOIN , FULL OUTER JOIN )

A cláusula JOIN em SQL é utilizada para combinar dados de duas ou

mais tabelas com base em uma condição lógica, normalmente uma
chave estrangeira. É essencial para normalização de dados e
consultas relacionais.

1. INNER JOIN – Interseção entre tabelas

Retorna apenas os registros que têm correspondência em ambas as

tabelas.

SELECT funcionarios.nome, departamentos.nome

FROM funcionarios
INNER JOIN departamentos
ON funcionarios.id_departamento = departamentos.id;

Só aparecem funcionários que têm departamento

correspondente.
INNER JOIN é o tipo mais comum de junção.

2. LEFT JOIN (ou LEFT OUTER JOIN ) – Todos da tabela da esquerda

Retorna todos os registros da tabela da esquerda, mesmo que não

haja correspondência na tabela da direita. Onde não houver
correspondência, os campos da tabela da direita retornam NULL .

SELECT funcionarios.nome, departamentos.nome

FROM funcionarios
LEFT JOIN departamentos
ON funcionarios.id_departamento = departamentos.id;
 Traz todos os funcionários, inclusive os sem departamento
definido.

3. RIGHT JOIN (ou RIGHT OUTER JOIN ) – Todos da tabela da direita

Retorna todos os registros da tabela da direita, mesmo que não haja

correspondência na tabela da esquerda.

SELECT funcionarios.nome, departamentos.nome

FROM funcionarios
RIGHT JOIN departamentos
ON funcionarios.id_departamento = departamentos.id;

Lista todos os departamentos, mesmo os sem funcionários

alocados.

4. FULL OUTER JOIN – União total

Retorna todos os registros das duas tabelas, e onde não houver

correspondência, preenche com NULL .

SELECT funcionarios.nome, departamentos.nome

FROM funcionarios
FULL OUTER JOIN departamentos
ON funcionarios.id_departamento = departamentos.id;

Traz:
Funcionários com e sem departamento
Departamentos com e sem funcionários

Observação: Nem todos os SGBDs suportam diretamente o FULL

OUTER JOIN (ex: MySQL até versões recentes não possui suporte
direto).

5. Especificação da junção com USING (quando os nomes das

colunas coincidem)
 SELECT *
FROM funcionarios
JOIN departamentos USING (id_departamento);

Usa USING(coluna_comum) para evitar repetição no ON .

Só funciona se a coluna tiver o mesmo nome em ambas as
tabelas.

6. Junção com alias de tabela

SELECT f.nome, d.nome

FROM funcionarios AS f
JOIN departamentos AS d ON f.id_departamento = d.id;

Cria apelidos ( f , d ) para melhorar a legibilidade e clareza.

7. Junções múltiplas

SELECT f.nome, d.nome, p.nome

FROM funcionarios f
JOIN departamentos d ON f.id_departamento = d.id
JOIN projetos p ON f.id_projeto = p.id;

Junção de mais de duas tabelas em cascata, com suas

respectivas chaves.

Resumo das junções

Tipo de JOIN O que retorna

INNER JOIN Apenas registros com correspondência nas duas tabelas

LEFT JOIN Todos os da tabela da esquerda + correspondentes da direita ou
NULL

RIGHT JOIN Todos os da tabela da direita + correspondentes da esquerda ou

NULL

FULL OUTER Todos os registros das duas tabelas, com NULL onde não há
JOIN correspondência
Concluímos a Parte 10: Cláusulas de Junção.

Deseja seguir para a Parte 11: Subconsultas (Subqueries: em

SELECT, WHERE e FROM)?

11. SQL – Subconsultas (Subqueries em SELECT , WHERE e FROM )

Subconsultas são instruções SELECT aninhadas dentro de outras

instruções SQL. São extremamente úteis quando precisamos obter
valores intermediários para filtros, comparações ou colunas
derivadas.

1. Subconsulta no WHERE – Filtro com valores derivados

SELECT nome
FROM funcionarios
WHERE salario > (SELECT AVG(salario) FROM funcionarios);

A subconsulta retorna a média dos salários.

O WHERE compara o salário de cada funcionário com esse valor.
Importante: a subconsulta retorna um único valor escalar.

2. Subconsulta no FROM – Como tabela derivada

SELECT departamento, media_salario

FROM (
SELECT id_departamento AS departamento, AVG(salario) AS
media_salario
FROM funcionarios
GROUP BY id_departamento
) AS medias;

A subconsulta no FROM cria uma tabela temporária chamada

medias .
Essa técnica é útil para agregar dados e depois usá-los em
novos cálculos ou filtros.

3. Subconsulta no SELECT – Coluna derivada

 SELECT nome,
(SELECT COUNT(*) FROM projetos WHERE
projetos.id_funcionario = funcionarios.id) AS qtd_projetos
FROM funcionarios;

A subconsulta retorna o número de projetos por funcionário.

Executa-se uma subconsulta para cada linha da tabela principal.

4. Subconsulta com IN , ANY , ALL , EXISTS

a) Usando IN :

SELECT nome
FROM funcionarios
WHERE id_departamento IN (
SELECT id FROM departamentos WHERE localizacao = 'São Paulo'
);

Seleciona funcionários cujos departamentos estão em São Paulo.

b) Usando EXISTS :

SELECT nome
FROM departamentos d
WHERE EXISTS (
SELECT 1 FROM funcionarios f WHERE f.id_departamento = d.id
);

Retorna apenas os departamentos que possuem ao menos um

funcionário.
EXISTS retorna true/false se a subconsulta retorna resultados.

c) Usando ALL e ANY :

SELECT nome
FROM funcionarios
 WHERE salario > ALL (SELECT salario FROM funcionarios WHERE
id_departamento = 3);

Retorna funcionários cujo salário é maior que todos os salários

do departamento 3.

5. Subconsultas correlacionadas

São subconsultas que dependem de valores da consulta externa.

SELECT nome
FROM funcionarios f1
WHERE salario > (
SELECT AVG(salario)
FROM funcionarios f2
WHERE f2.id_departamento = f1.id_departamento
);

A média de salários é calculada por departamento.

Para cada funcionário, compara com a média do seu próprio
departamento.

Regras e restrições importantes

Subconsultas podem retornar:

Um valor escalar (para comparação direta)
Uma lista (para uso com IN )
Um conjunto de colunas/linhas (quando usada como tabela
derivada)
A subconsulta deve estar entre parênteses.
Nem todos os SGBDs permitem ORDER BY dentro de subqueries
exceto com TOP , LIMIT ou se usada com IN/EXISTS .

Exemplo realista combinado

SELECT nome
FROM funcionarios
 WHERE salario > (
SELECT AVG(salario)
FROM funcionarios
WHERE id_departamento = (
SELECT id FROM departamentos WHERE nome = 'TI'
)
);

Traz funcionários com salário acima da média do departamento

de TI.

Conclusão da Parte 11: Subconsultas

Próximo tema será:

Parte 12: Views (Criação e uso de visões virtuais com CREATE VIEW
e SELECT em VIEW)
Prosseguir?

12. SQL – Views (Criação e uso de visões virtuais com CREATE VIEW e
SELECT em View)

Views são consultas salvas no banco de dados, tratadas como se

fossem tabelas. Elas não armazenam dados fisicamente, mas sim a
lógica de uma consulta que será executada sempre que a view for
chamada.

1. Criação de uma View simples com CREATE VIEW

CREATE VIEW vw_funcionarios_ti AS

SELECT id, nome, salario
FROM funcionarios
WHERE id_departamento = 2;

Cria uma view chamada vw_funcionarios_ti .

Toda vez que ela for consultada, executará esse SELECT .
Ideal para esconder complexidade ou restringir acesso a dados.

2. Uso de SELECT em uma View

 SELECT nome, salario
FROM vw_funcionarios_ti;

A sintaxe é idêntica à de uma tabela.

O SGBD executará automaticamente o SQL definido na criação
da view.

3. Atualização de Views

É possível atualizar uma View se ela for atualizável, ou seja:

Baseada em uma única tabela,

Sem funções de agregação,
Sem cláusulas GROUP BY , DISTINCT , HAVING , etc.

UPDATE vw_funcionarios_ti
SET salario = salario * 1.1
WHERE nome = 'Ana';

Isso só funcionará se a view atender aos requisitos acima.

4. Views com junções

CREATE VIEW vw_funcionarios_departamentos AS

SELECT f.nome, f.salario, d.nome AS departamento
FROM funcionarios f
JOIN departamentos d ON f.id_departamento = d.id;

Combina dados de duas tabelas.

Pode ser útil para relatórios e dashboards.

5. Views com agregações (somente leitura)

CREATE VIEW vw_media_salario_por_departamento AS

SELECT id_departamento, AVG(salario) AS media
 FROM funcionarios
GROUP BY id_departamento;

Boa para criar relatórios reutilizáveis.

Essa view não pode ser atualizada diretamente.

6. Alteração e exclusão de Views

a) Alterar (forma mais segura: recriar):

CREATE OR REPLACE VIEW vw_funcionarios_ti AS

SELECT id, nome, salario
FROM funcionarios
WHERE id_departamento = 3;

b) Excluir:

DROP VIEW vw_funcionarios_ti;

7. Benefícios das Views

Segurança: pode-se restringir colunas e registros.

Reuso de lógica: centraliza SQLs complexos.
Facilidade de manutenção: se a estrutura muda, altera-se
apenas a view.
Abstração: os usuários acessam a view como se fosse uma
tabela simples.

8. Considerações Importantes

Característica É permitida em Views?

JOIN ✅ Sim
GROUP BY ✅ Sim (somente leitura)
DISTINCT ✅ Sim (somente leitura)
ORDER BY ❌ Não (exceto com TOP ou LIMIT )
 Views com ORDER BY geralmente não são suportadas
diretamente, a menos que estejam combinadas com uma
cláusula de limitação (como LIMIT ou TOP ).
A execução de uma view é sempre dinâmica, refletindo dados
atualizados.

Exemplo realista combinado

CREATE VIEW vw_total_vendas_por_cliente AS

SELECT c.nome, SUM(v.valor) AS total
FROM clientes c
JOIN vendas v ON v.id_cliente = c.id
GROUP BY c.nome;

-- Uso:
SELECT * FROM vw_total_vendas_por_cliente WHERE total > 1000;

Conclusão da Parte 12: Views

Próximo tema será:

Parte 13: Índices ( CREATE INDEX , uso e impactos na performance)
Deseja prosseguir?

13. SQL – Índices (CREATE INDEX, uso e impactos na performance)

Índices são estruturas de dados auxiliares criadas sobre colunas de

uma tabela para acelerar consultas, especialmente nas cláusulas
WHERE , JOIN , ORDER BY e GROUP BY .

1. Criação de Índice com CREATE INDEX

CREATE INDEX idx_nome_cliente ON clientes (nome);

Cria um índice chamado idx_nome_cliente sobre a coluna nome

da tabela clientes .
Esse índice será usado pelo otimizador para acelerar buscas que
filtram ou ordenam por nome .
2. Índice composto (mais de uma coluna)

CREATE INDEX idx_cliente_estado_cidade ON clientes (estado,

cidade);

Útil quando as consultas frequentemente usam as duas colunas

juntas em cláusulas WHERE .

⚠️ A ordem importa: esse índice é eficiente para filtros por (estado)

ou (estado, cidade) , mas não para cidade isoladamente.

3. Consulta beneficiada por índice

SELECT * FROM clientes WHERE nome = 'Carlos';

Se houver um índice na coluna nome , a busca será feita por

varredura do índice (index seek), e não da tabela inteira (table
scan).

4. Consulta que pode não usar índice (exemplo ruim)

SELECT * FROM clientes WHERE UPPER(nome) = 'CARLOS';

Se o índice foi criado em nome , mas a função UPPER() está

aplicada na consulta, o índice não será utilizado.
Para aproveitar o índice, evite funções nas colunas indexadas.

5. Remoção de índice

DROP INDEX idx_nome_cliente ON clientes;

Remove o índice idx_nome_cliente .

6. Impactos positivos do uso de índices

✅ Desempenho melhorado em:

 Consultas SELECT com filtros e junções,
Ordenações ( ORDER BY ),
Agrupamentos ( GROUP BY ),
Verificações de existência ( EXISTS ), IN , LIKE (com cuidado).

7. Impactos negativos dos índices

❌ Custo em inserções, atualizações e deleções:

Sempre que um INSERT , UPDATE ou DELETE for executado, o

índice também precisa ser mantido, o que torna essas
operações mais lentas.

❌ Consumo de espaço:

Índices ocupam espaço em disco, proporcional à tabela e número

de colunas indexadas.

8. Cuidados e boas práticas

Crie índices para colunas frequentemente filtradas ou

ordenadas.
Evite criar muitos índices — cada um afeta desempenho em
escrita e ocupa espaço.
Analise consultas reais e use ferramentas de plano de execução
( EXPLAIN , SHOW PLAN , etc.).
Prefira índices compostos bem planejados do que vários índices
simples isolados.

9. Índice único ( UNIQUE )

CREATE UNIQUE INDEX idx_cpf_unico ON clientes (cpf);

Garante que não existam valores duplicados na coluna cpf .

10. Índices e LIKE

 Usam índice se o padrão não começa com % :

-- Usa índice:
SELECT * FROM produtos WHERE nome LIKE 'Caf%';

-- Não usa índice (varredura completa):

SELECT * FROM produtos WHERE nome LIKE '%Caf';

Conclusão da Parte 13: Índices

Próximo tema será:

Parte 14: Transações (BEGIN, COMMIT, ROLLBACK e controle de
atomicidade e consistência)
Deseja prosseguir?

14. SQL – Transações (BEGIN, COMMIT, ROLLBACK e controle de

atomicidade e consistência)

Transações são blocos de comandos SQL que são executados como

uma unidade atômica. Ou seja, ou todos os comandos são
executados com sucesso, ou nenhum é aplicado. Isso garante
consistência, integridade e confiabilidade em operações com
bancos de dados.

1. Início de uma transação: BEGIN / START TRANSACTION

BEGIN;
-- ou
START TRANSACTION;

Marca o início de uma transação. A partir desse ponto, as

alterações no banco só serão permanentes se houver um
COMMIT .

2. Confirmação de transação: COMMIT

COMMIT;
 Confirma todas as operações realizadas desde o BEGIN .
As mudanças se tornam visíveis permanentemente para os
outros usuários e sessões.

3. Cancelamento de transação: ROLLBACK

ROLLBACK;

Desfaz todas as alterações feitas desde o BEGIN .

Útil para evitar corrupção ou inconsistência de dados em caso
de erro durante o processo.

4. Exemplo prático: transferência bancária

BEGIN;

UPDATE contas SET saldo = saldo - 100 WHERE id = 1; -- débito

UPDATE contas SET saldo = saldo + 100 WHERE id = 2; -- crédito

COMMIT;

Transação atômica: ou o valor é debitado de uma conta e

creditado na outra, ou nada acontece.
Se qualquer linha falhar (ex: conta não encontrada), um ROLLBACK
garante que nenhuma modificação parcial fique no banco.

5. Exemplo com erro e ROLLBACK

BEGIN;

UPDATE contas SET saldo = saldo - 500 WHERE id = 1;

-- Erro: conta 99 não existe
UPDATE contas SET saldo = saldo + 500 WHERE id = 99;

ROLLBACK;

O erro na segunda instrução invalida a operação.

 O ROLLBACK garante que o valor não seja debitado da conta 1
erroneamente.

6. Controle de consistência e atomicidade

Atomicidade: tudo ou nada — a transação executa integralmente

ou é desfeita.
Consistência: o banco de dados permanece em um estado
válido antes e depois da transação.
Isolamento: outras transações não veem alterações parciais.
Durabilidade: após um COMMIT , os dados permanecem salvos
mesmo em falhas de energia ou sistema (garantido pelo SGBD).

Esses princípios formam o conhecido modelo ACID:

Letra Significado Garantia

A Atomicidade Tudo ou nada

C Consistência O banco permanece válido
I Isolamento Transações independentes não interferem entre si
D Durabilidade Alterações confirmadas persistem, mesmo com falhas

7. Transações implícitas vs. explícitas

Alguns SGBDs (como MySQL em modo padrão) realizam

transações implícitas a cada comando INSERT , UPDATE , DELETE .
Para controle mais fino, use transações explícitas com BEGIN ,
COMMIT , ROLLBACK .

8. Dicas práticas

Sempre use transações explícitas em operações críticas, como

movimentações financeiras, alterações em múltiplas tabelas, etc.
Nunca finalize uma transação sem um COMMIT ou ROLLBACK .
Use ROLLBACK em blocos de tratamento de erro.
15. SQL – Controle de Permissões (GRANT, REVOKE, usuários e
segurança)

O controle de permissões em SQL permite gerenciar quem pode

acessar e o que pode fazer com os objetos do banco de dados
(tabelas, views, procedures, etc.). Isso é fundamental para garantir a
segurança e integridade dos dados.

1. GRANT – Concedendo Permissões

GRANT tipo_permissao ON objeto TO usuario;

Concede permissões específicas a um usuário ou função para

operar sobre um objeto.
tipo_permissao pode ser: SELECT , INSERT , UPDATE , DELETE , ALL
PRIVILEGES , entre outros.

Exemplo:

GRANT SELECT, INSERT ON clientes TO joao;

Permite que o usuário joao execute comandos SELECT e INSERT

na tabela clientes .

Exemplo com WITH GRANT OPTION :

GRANT SELECT ON produtos TO ana WITH GRANT OPTION;

ana pode usar SELECT na tabela produtos e também conceder

essa permissão a outros usuários.

2. REVOKE – Revogando Permissões

REVOKE tipo_permissao ON objeto FROM usuario;

Revoga as permissões anteriormente concedidas.

Exemplo:

REVOKE INSERT ON clientes FROM joao;

Retira a permissão de INSERT da tabela clientes do usuário

joao .

3. Criação e Gerenciamento de Usuários (em SGBDs como MySQL,

PostgreSQL)

Criar usuário:

CREATE USER joao IDENTIFIED BY 'senha123';

Alterar senha:

ALTER USER joao IDENTIFIED BY 'novaSenha!';

Remover usuário:

DROP USER joao;

4. Privilégios comuns em SQL:

Permissão Descrição

SELECT Ler dados

INSERT Inserir dados
UPDATE Modificar dados
DELETE Excluir dados
ALL PRIVILEGES Concede todas as permissões
EXECUTE Executar procedures e funções armazenadas
USAGE Utilizar esquema, sequência, etc.
REFERENCES Criar chaves estrangeiras

5. Segurança: boas práticas

 Princípio do menor privilégio: conceda apenas as permissões
necessárias.
Crie grupos de usuários com funções específicas para facilitar a
gestão (roles).
Evite usar usuários administrativos ( root , postgres ) em
aplicações.
Monitore e audite concessões e revogações regularmente.

6. Exemplo avançado com roles (PostgreSQL)

CREATE ROLE leitores;

GRANT SELECT ON ALL TABLES IN SCHEMA public TO leitores;

GRANT leitores TO maria;

Cria uma role leitores com acesso de leitura a todas as tabelas

no schema public .
Concede essa role para o usuário maria .

7. Restrições por nível de objeto

Você pode conceder permissões:

Por banco de dados

Por schema
Por tabela
Por coluna
Por função/procedure

Exemplo – permissão de leitura apenas em uma coluna:

GRANT SELECT(nome, cpf) ON clientes TO joao;

Conclusão da Parte 15: Permissões

O controle de permissões com GRANT e REVOKE é essencial para
garantir segurança, integridade e isolamento entre diferentes
usuários e aplicações em um ambiente de banco de dados.

Fonte principal:

PostgreSQL Documentation – GRANT and REVOKE

https://www.postgresql.org/docs/current/sql-grant.html
MySQL Documentation – GRANT Syntax:
https://dev.mysql.com/doc/refman/8.0/en/grant.html
GUERRA, Cláudio de Souza. Banco de Dados – Série Provas &
Concursos – Elsevier, 2020. (Cap. 6 – Segurança, p. 153–159)

16. SQL – Procedimentos Armazenados (Stored Procedures e

controle de lógica no SGBD)

Procedimentos armazenados (Stored Procedures) são blocos de

código SQL armazenados no banco de dados que podem ser
executados várias vezes, com ou sem parâmetros. Eles encapsulam
lógica de negócios no próprio SGBD, melhorando performance,
segurança e reutilização.

1. Sintaxe básica de criação (exemplo em MySQL)

DELIMITER $$

CREATE PROCEDURE nome_procedimento (IN parametro1 INT, OUT

parametro2 VARCHAR(50))
BEGIN
-- Bloco de comandos SQL
SELECT coluna INTO parametro2 FROM tabela WHERE id =
parametro1;
END $$

DELIMITER ;

IN : parâmetro de entrada
 OUT : parâmetro de saída
INOUT : parâmetro de entrada e saída
O uso de DELIMITER serve para o interpretador entender o fim da
procedure (MySQL).

2. Exemplo simples: Procedure sem parâmetros

DELIMITER //

CREATE PROCEDURE listar_produtos()

BEGIN
SELECT * FROM produtos;
END //

DELIMITER ;

Cria uma procedure que lista todos os produtos.

Pode ser executada com:

CALL listar_produtos();

3. Procedure com lógica condicional

DELIMITER //

CREATE PROCEDURE atualizar_estoque(IN id_prod INT, IN nova_qtd

INT)
BEGIN
IF nova_qtd >= 0 THEN
UPDATE produtos SET quantidade = nova_qtd WHERE id =
id_prod;
ELSE
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Quantidade
inválida';
END IF;
END //
 DELIMITER ;

Inclui lógica condicional ( IF ), permitindo regras de validação

internas.
SIGNAL emite erro personalizado (MySQL ≥ 5.5).

4. Controle de fluxo dentro da procedure

Comando Finalidade

IF...THEN Condição simples

CASE Condições múltiplas
WHILE Laço de repetição
LOOP Loop simples (sem condição de saída)
REPEAT Loop com condição no final
LEAVE Saída de um bloco
ITERATE Pula para a próxima iteração do loop

5. Vantagens dos Stored Procedures

Performance: Evita recompilação de instruções repetidas.

Segurança: Controle granular de acesso via GRANT EXECUTE .
Reutilização: Lógica de negócio centralizada.
Menor tráfego: Reduz envio de comandos repetidos da
aplicação.

6. Procedimentos armazenados vs Triggers

Característica Stored Procedure Trigger

Executado via comando Sim ( CALL nome() ) Não (executado automaticamente)

Lógica encapsulada Sim Sim
Controle explícito Sim Não (executado por evento)
7. Alteração e exclusão

DROP PROCEDURE nome_procedimento;

Não é possível “editar” uma procedure diretamente: é necessário

descartá-la ( DROP ) e recriá-la.

8. Controle de permissões com GRANT/REVOKE

GRANT EXECUTE ON PROCEDURE atualizar_estoque TO usuario;

Permite que o usuario execute apenas a procedure

atualizar_estoque , sem acesso direto às tabelas.

9. Suporte por SGBDs

SGBD Suporta? Linguagem Procedural

MySQL Sim SQL/PSM

PostgreSQL Sim PL/pgSQL, PL/Python, PL/Perl, etc.
SQL Server Sim T-SQL
Oracle Sim PL/SQL

10. Conclusão da Parte 16:

Procedures permitem centralizar e organizar a lógica de negócios

no próprio banco de dados, com mais segurança e reutilização. São
essenciais em aplicações críticas e ambientes com alta
complexidade transacional.

Fonte principal:

MySQL Reference Manual – Stored Procedures and Functions

PostgreSQL Documentation – Stored Procedures
GUERRA, Cláudio de Souza. Banco de Dados – Série Provas &
Concursos – Elsevier, 2020. (Cap. 7 – Programação no Banco de
 Dados, p. 161–178)

17. SQL – Triggers (Gatilhos automáticos com BEFORE, AFTER,

INSERT, UPDATE, DELETE)

Triggers (ou gatilhos) são objetos de banco de dados que executam

automaticamente um bloco de instruções em resposta a eventos
DML ( INSERT , UPDATE , DELETE ) em uma tabela ou visão. Servem para
automatizar regras de negócio, manter consistência de dados, ou
auditar alterações.

1. Estrutura básica de uma trigger (MySQL)

CREATE TRIGGER nome_trigger

[BEFORE | AFTER] [INSERT | UPDATE | DELETE]
ON nome_tabela
FOR EACH ROW
BEGIN
-- Bloco de comandos SQL
END;

BEFORE : executa antes do evento.

AFTER : executa após o evento.
FOR EACH ROW : define que a trigger será disparada por linha
afetada.

2. Exemplo: Trigger AFTER INSERT para log

CREATE TRIGGER log_insercao_produto

AFTER INSERT ON produtos
FOR EACH ROW
BEGIN
INSERT INTO log_produtos(acao, id_produto, data)
VALUES ('INSERÇÃO', NEW.id, NOW());
END;

NEW.coluna : acessa o novo valor inserido.

 OLD.coluna : acessa o valor antigo (usado em UPDATE ou DELETE ).

3. Exemplo: Trigger BEFORE UPDATE para impedir alteração negativa

CREATE TRIGGER valida_estoque

BEFORE UPDATE ON produtos
FOR EACH ROW
BEGIN
IF NEW.quantidade < 0 THEN
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Estoque não
pode ser negativo';
END IF;
END;

Impede que um UPDATE torne a quantidade negativa.

Usa SIGNAL para gerar erro customizado.

4. Eventos possíveis para Triggers

Tipo de Trigger Quando é Executada

BEFORE INSERT Antes de inserir uma nova linha

AFTER INSERT Após inserção de nova linha
BEFORE UPDATE Antes de alterar uma linha existente
AFTER UPDATE Após a alteração
BEFORE DELETE Antes de apagar uma linha
AFTER DELETE Após apagar a linha

5. Uso de OLD e NEW

Tipo de TriggerPode usar OLD ?Pode usar NEW ?

INSERT ❌ ✅
UPDATE ✅ ✅
DELETE ✅ ❌
6. Casos de uso comuns

Auditoria: rastrear alterações em tabelas sensíveis.

Validação: impedir dados inconsistentes antes de inserção.
Automatização: atualizar ou replicar dados em tabelas auxiliares.
Logs: manter histórico de mudanças em registros.

7. Restrições e boas práticas

Não é possível criar triggers em views (somente em tabelas).

Triggers não retornam valores diretamente.
Evite lógica muito complexa que encadeie múltiplos gatilhos –
isso dificulta manutenção e impacta desempenho.
Use SIGNAL para abortar operações com mensagens claras.

8. Exclusão de trigger

DROP TRIGGER nome_trigger;

9. Comparativo: Triggers vs Stored Procedures

Característica Trigger Stored Procedure

Execução Sim Não (execução manual via

automática CALL )

Associada a Sim (INSERT, UPDATE, Não

eventos DELETE)
Retorno de valores Não Sim (com OUT/INOUT)
Ideal para auditoria Sim Não (não é automática)

10. Conclusão da Parte 17:

Triggers são ferramentas poderosas para garantir integridade,

automação e auditoria no banco de dados. Contudo, devem ser
usadas com cautela para evitar sobrecarga no desempenho e
complexidade excessiva na lógica de negócios.
Fontes:

MySQL 8.0 Reference Manual – CREATE TRIGGER Syntax

PostgreSQL Documentation – Triggers
GUERRA, Cláudio de Souza. Banco de Dados – Série Provas &
Concursos – Elsevier, 2020. Cap. 7 – Triggers (p. 179–185)

18. SQL – Funções Definidas pelo Usuário (User-Defined Functions –

UDFs)

As User-Defined Functions (UDFs) permitem encapsular código SQL

reutilizável dentro de uma função customizada que retorna um valor.
São úteis para cálculos, transformações de dados e lógicas
reutilizáveis diretamente em consultas SQL, promovendo
organização e legibilidade.

1. Estrutura básica de uma UDF escalar (MySQL)

CREATE FUNCTION nome_funcao (parametro1 TIPO, parametro2 TIPO,

...)
RETURNS tipo_retorno
DETERMINISTIC
BEGIN
DECLARE variavel TIPO;
-- lógica de processamento
RETURN valor;
END;

RETURNS : define o tipo de retorno (ex: INT , VARCHAR , DECIMAL ,

etc.).
DETERMINISTIC : indica que para os mesmos parâmetros, o
resultado será sempre o mesmo.
Pode usar DECLARE , IF , CASE , SET , etc.

2. Exemplo 1: Função que calcula o valor total com imposto

 CREATE FUNCTION calcular_total_com_imposto(preco DECIMAL(10,2),
taxa DECIMAL(5,2))
RETURNS DECIMAL(10,2)
DETERMINISTIC
BEGIN
RETURN preco + (preco * taxa / 100);
END;

Uso:

SELECT nome, calcular_total_com_imposto(preco, 10) AS

preco_final FROM produtos;

3. Exemplo 2: Função para retornar status textual de estoque

CREATE FUNCTION status_estoque(qtd INT)

RETURNS VARCHAR(20)
DETERMINISTIC
BEGIN
IF qtd = 0 THEN
RETURN 'Sem estoque';
ELSEIF qtd < 10 THEN
RETURN 'Estoque baixo';
ELSE
RETURN 'Estoque OK';
END IF;
END;

Uso:

SELECT nome, status_estoque(quantidade) FROM produtos;

4. Tipos de funções definidas pelo usuário

Tipo Descrição Exemplo de uso

Escalar Retorna um único valor calcular_idade(data_nascimento)

 Tipo Descrição Exemplo de uso

Tabela (T- Retorna um conjunto de linhas retornar_produtos_acima_media()

SQL) (semelhante a view)

Em MySQL, apenas funções escalares são suportadas diretamente.

5. Boas práticas

Dê nomes descritivos para as funções.

Documente parâmetros e propósito da função.
Use DETERMINISTIC quando aplicável (otimiza performance).
Evite lógica muito complexa ou que dependa de muitos acessos
ao disco.
Prefira funções para lógicas de negócios reutilizáveis.

6. Diferenças entre UDF, Stored Procedures e Views

Característica UDF Stored Procedure View

Retorna valor ✅ Sim ❌ Não ✅ (conjunto de

direto (obrigatório) necessariamente dados)
Usada em ✅ Sim ❌ Não ✅ Sim
SELECT
Pode alterar ❌ Não ✅ Sim ❌ Não
dados
Reutilizável ✅ Sim ✅ Sim ✅ Sim

7. Exclusão de uma UDF

DROP FUNCTION nome_funcao;

8. Restrições e limitações
 UDFs não podem conter comandos DML ( INSERT , UPDATE ,
DELETE ) em MySQL.
Não podem chamar Stored Procedures .
São executadas por linha, o que pode impactar performance em
grandes conjuntos de dados.

9. Casos de uso típicos

Cálculo de impostos, descontos, margens.

Verificações de status de campos (ex: "ativo"/"inativo").
Transformações de strings (ex: concatenar CPF formatado).
Reutilização de lógica de negócio simples.

10. Conclusão da Parte 18:

UDFs são ferramentas poderosas para manter a lógica de negócio

organizada e reaproveitável dentro do banco de dados. Embora não
substituam Stored Procedures ou Views, são ideais para operações
personalizadas de transformação e cálculo, diretamente aplicáveis
em SELECT .

Fontes:

MySQL 8.0 Reference Manual – CREATE FUNCTION Syntax

SQL Server Docs – User-Defined Functions (UDFs)
GUERRA, Cláudio de Souza. Banco de Dados – Série Provas &
Concursos – Elsevier, 2020. Cap. 8 – Funções do Usuário (p. 191–
198)

19. SQL – Tópicos Avançados (CTEs, WITH, Recursividade, CASE,

Window Functions)

Nesta parte, abordamos recursos avançados da linguagem SQL que

elevam a capacidade de manipulação e análise de dados, muito
cobrados em provas de alto nível.
1. CTE – Common Table Expression (expressão de tabela
comum)

A CTE é uma subconsulta nomeada, definida com WITH , que pode

ser referenciada dentro da consulta principal.

Sintaxe básica:

WITH nome_cte AS (
SELECT ...
)
SELECT * FROM nome_cte;

Exemplo:

WITH vendas_2024 AS (
SELECT cliente_id, SUM(valor) AS total
FROM vendas
WHERE ano = 2024
GROUP BY cliente_id
)
SELECT * FROM vendas_2024 WHERE total > 10000;

2. CTE Recursiva

Permite trabalhar com hierarquias ou estruturas recursivas (ex:

árvore de diretórios, organogramas).

Exemplo – Hierarquia de funcionários:

WITH RECURSIVE hierarquia AS (

SELECT id, nome, chefe_id
FROM funcionarios
WHERE chefe_id IS NULL -- nível 1

UNION ALL

SELECT f.id, f.nome, f.chefe_id

FROM funcionarios f
 INNER JOIN hierarquia h ON f.chefe_id = h.id
)
SELECT * FROM hierarquia;

⚠️ Nem todos os SGBDs suportam recursividade (MySQL 8+ e

PostgreSQL sim).

3. CASE – Expressão condicional

Permite retornar valores diferentes dependendo de condições.

Similar ao IF ou SWITCH .

Exemplo:

SELECT nome,
CASE
WHEN salario < 3000 THEN 'Baixo'
WHEN salario BETWEEN 3000 AND 7000 THEN 'Médio'
ELSE 'Alto'
END AS faixa_salarial
FROM empregados;

Pode ser usado em SELECT , WHERE , ORDER BY , etc.

4. Funções de Janela (Window Functions)

Executam cálculos sem agrupar os dados, mantendo o nível de

detalhe linha a linha. Usam a cláusula OVER .

Principais:

Função Descrição

ROW_NUMBER() Número sequencial de cada linha

RANK() Classificação com empates
 Função Descrição

DENSE_RANK() Classificação sem pulos em empates

SUM() OVER() Soma cumulativa
AVG() OVER() Média em janela
LAG() , LEAD() Valor anterior/próximo na janela

Exemplo – ROW_NUMBER() :

SELECT nome, departamento,

ROW_NUMBER() OVER(PARTITION BY departamento ORDER BY
salario DESC) AS ranking
FROM empregados;

PARTITION BY : divide em grupos (como GROUP BY , mas sem

reduzir).
ORDER BY : ordena dentro da janela.

Exemplo – LAG() e LEAD() :

SELECT nome, salario,

LAG(salario) OVER(ORDER BY salario) AS salario_anterior,
LEAD(salario) OVER(ORDER BY salario) AS salario_proximo
FROM empregados;

5. Vantagens e Aplicações

Recurso Uso comum

CTE Substitui subconsultas aninhadas, melhora legibilidade

CTE recursiva Consultas hierárquicas, como organogramas ou categorias
CASE Classificações condicionais em relatórios
Window Functions Análises detalhadas, comparações entre linhas adjacentes

6. Sintaxe geral da cláusula OVER

 função() OVER (
PARTITION BY coluna1
ORDER BY coluna2
ROWS BETWEEN ...
)

Pode-se usar janelas móveis (ex: ROWS BETWEEN 1 PRECEDING AND

CURRENT ROW ) para cálculos dinâmicos.

7. Restrições

CTEs não melhoram performance diretamente (são apenas

sintaxe mais clara).
Algumas funções de janela requerem suporte explícito no SGBD
(Oracle, PostgreSQL, SQL Server, MySQL 8+).
CTEs recursivas podem causar loops infinitos se mal construídas
(use LIMIT ou MAXRECURSION em alguns SGBDs).

Conclusão da Parte 19

Tópicos como CTEs, funções de janela e o uso do CASE tornam o

SQL extremamente poderoso para análise de dados, rankings,
comparações entre registros e manipulação de hierarquias, sendo
essenciais para concursos que cobram SQL com profundidade.

Fontes

MySQL 8.0 Reference Manual – CTEs and Recursive Queries

PostgreSQL Docs – Window Functions
GUERRA, Cláudio de Souza. Banco de Dados – Série Provas &
Concursos – Elsevier, 2020. Cap. 9, 10 e 11
ELMAZRI, Ramez; NAVATHE, Shamkant. Fundamentos de
Sistemas de Banco de Dados, 7ª ed. Pearson, 2019. Cap. 6 e 7

20. SQL – Normalização e Formas Normais

A normalização é um processo teórico usado no projeto de banco de
dados relacional que visa eliminar redundâncias, inconsistências e
anomalias de atualização. A ideia é estruturar os dados de forma
eficiente e lógica, distribuindo-os entre tabelas por meio de regras
conhecidas como formas normais (1FN, 2FN, 3FN, etc.).

1. O que é Normalização?

É um processo que transforma um modelo de dados em estruturas

mais simples e sem redundância, mantendo a integridade dos
dados.

O objetivo é melhorar o desempenho de escritas/atualizações e

garantir integridade lógica, mesmo que isso signifique um leve custo
em performance de leitura (JOINs adicionais).

2. Primeira Forma Normal (1FN)

Requisitos:

Os atributos devem ser atômicos (não multivalorados nem

compostos).
As colunas devem conter apenas um valor por célula.
A ordem das linhas e colunas não influencia.

Exemplo incorreto (violação da 1FN):

Cliente_ID Nome Telefones

1 João (11)9999-0001, 0002

Forma correta (após normalização):

Cliente_ID Nome Telefone

1 João (11)9999-0001
1 João (11)9999-0002

3. Segunda Forma Normal (2FN)

Pré-requisito: estar na 1FN

Requisitos adicionais:

Eliminar dependências parciais, ou seja, atributos que

dependem de parte de uma chave primária composta.

Exemplo violando 2FN:

MatrículaDisciplinaNomeAlunoNomeCurso

→ Aqui, NomeAluno e NomeCurso dependem apenas da matrícula, não

da chave composta ( Matrícula + Disciplina ). Deve-se separar em
duas tabelas.

4. Terceira Forma Normal (3FN)

Pré-requisito: estar na 2FN

Requisitos adicionais:

Eliminar dependências transitivas, ou seja, quando um atributo

depende de outro atributo não-chave.

Exemplo violando 3FN:

Func_ID Nome Dept_ID NomeDepto

→ NomeDepto depende de Dept_ID , não da chave primária Func_ID .

Correção: criar tabela separada para departamentos.

5. Forma Normal de Boyce-Codd (BCNF)

É uma versão mais rigorosa da 3FN:

Toda dependência funcional deve ser de uma superchave.

Se houver mais de uma chave candidata, todas as dependências
devem partir de qualquer uma delas.

Exemplo:
Se Curso + Professor é chave, mas Curso → Professor , então está
fora da BCNF, pois Curso sozinho determina Professor .

6. Outras Formas Normais Avançadas (raro em

concursos)

4FN: trata dependências multivaloradas.

5FN: trata junções complexas e projetivas.
6FN: aplicada em bancos temporais.

Para concursos, 3FN e BCNF são o foco.

7. Vantagens da Normalização

Vantagem Descrição

Elimina redundância Dados duplicados são evitados

Evita anomalias Previne problemas em UPDATE, INSERT e DELETE
Melhora integridade Os dados são logicamente organizados e relacionados
Facilita manutenção Alterações estruturais afetam menos partes do sistema

8. Desvantagens (ou trade-offs)

 Desvantagem Impacto

Mais JOINs Aumenta a complexidade de consultas

Desempenho de leitura Pode cair em sistemas com alto volume de leitura
Modelagem mais Requer análise cuidadosa e compreensão de
complexa dependências

9. Quando Denormalizar

Em alguns sistemas voltados à leitura intensa (ex: BI, OLAP), pode-se

denormalizar (parcial ou totalmente) visando performance.

10. Aplicações em Concursos (CEBRASPE)

Perguntas teóricas sobre definição de formas normais.

Identificação de tabelas que violam formas normais.
Casos de anomalias e decisões de modelagem.
Diferença entre 3FN e BCNF.

Fontes:

NAVATHE, Shamkant; ELMASRI, Ramez. Fundamentos de

Sistemas de Banco de Dados, 7ª Ed., Pearson, 2019. Capítulo 15.
DATE, C. J. Introdução a Sistemas de Bancos de Dados. 8ª Ed.,
Pearson, 2004. Cap. 12.
SILBERSCHATZ, Abraham et al. Sistemas de Banco de Dados, 6ª
Ed., Pearson, 2013. Capítulo 7.
W3Schools – SQL Normalization

21. SQL – Modelagem Relacional e Entidade-Relacionamento (ER)

O modelo entidade-relacionamento (ER) é uma técnica de

modelagem conceitual que descreve a estrutura lógica dos dados,
suas entidades, atributos e os relacionamentos entre elas. É a base
para a criação de modelos relacionais implementáveis em um SGBD
relacional.
1. Conceitos Fundamentais do Modelo ER
Entidade

Representa um objeto do mundo real.

Exemplo: Aluno , Professor , Curso .

Atributo

Informação associada a uma entidade.

Exemplo: Nome , CPF , DataNascimento .

Chave Primária (Primary Key)

Um ou mais atributos que identificam unicamente uma entidade.

Exemplo: Matrícula no aluno.

Relacionamento

Conexão entre duas ou mais entidades.

Exemplo: Um Aluno matricula-se em um Curso .

2. Tipos de Entidades e Atributos

Tipo Descrição

Entidade forte Existe independentemente (ex: Aluno)

Entidade fraca Depende de outra para existir (ex: ItemPedido depende de
Pedido)
Atributo simples Não pode ser dividido (ex: CPF)
Atributo composto Pode ser subdividido (ex: Endereço → Rua, CEP)
Atributo Pode ter múltiplos valores (ex: Telefones)
multivalorado
Atributo derivado Pode ser calculado (ex: Idade derivada de DataNascimento)

3. Grau e Cardinalidade de Relacionamentos

Grau
 Número de entidades envolvidas no relacionamento.
Binário: entre 2 entidades.
Ternário: entre 3 entidades, etc.

Cardinalidade

Define quantas ocorrências de uma entidade se associam à

outra.
1:1 → Um para um
1:N → Um para muitos
N:M → Muitos para muitos

Exemplo:

Um aluno pode se matricular em vários cursos → 1:N

Um curso pode ter vários alunos → N:M
→ Esse N:M é geralmente resolvido com entidades associativas
no modelo relacional.

4. Transformação do Modelo ER para Relacional

Elemento ER Transformação Relacional

Entidade forte Tabela com atributos + chave primária

Entidade fraca Tabela com chave parcial + chave estrangeira da entidade
forte
Relacionamento 1:N Chave estrangeira na entidade do lado N
Relacionamento N:M Nova tabela associativa com as chaves estrangeiras
Atributo Nova tabela com FK apontando para a entidade
multivalorado
Atributo composto Pode ser dividido em colunas distintas ou tratado
separadamente

5. Notações Comuns

Chen (mais didática para ensino)

 Crow's Foot (pé de galinha): muito usada em modelagem prática
com CASE tools (ex: MySQL Workbench, ERWin)
UML (Unified Modeling Language): também pode representar
diagramas de classe semelhantes a ER

6. Exemplo de Conversão ER → Relacional

Modelo ER:

Entidades: Aluno (ID, Nome) , Curso (ID, NomeCurso)

Relacionamento: Matricula (DataMatricula) , entre Aluno e Curso
(N:M)

Tabelas resultantes:

CREATE TABLE Aluno (

ID INT PRIMARY KEY,
Nome VARCHAR(100)
);

CREATE TABLE Curso (

ID INT PRIMARY KEY,
NomeCurso VARCHAR(100)
);

CREATE TABLE Matricula (

IDAluno INT,
IDCurso INT,
DataMatricula DATE,
PRIMARY KEY (IDAluno, IDCurso),
FOREIGN KEY (IDAluno) REFERENCES Aluno(ID),
FOREIGN KEY (IDCurso) REFERENCES Curso(ID)
);

7. Aplicações em Concursos (CEBRASPE)

Interpretação de modelos ER para modelagem relacional.

Cardinalidade e tipos de relacionamentos.
 Transformações corretas para tabelas relacionais.
Diferenças entre entidade forte e fraca.
Reconhecimento de atributos compostos, multivalorados e
derivados.

8. Boas Práticas

Evitar atributos multivalorados (ou tratá-los corretamente).

Usar nomes significativos para entidades e relacionamentos.
Verificar a cardinalidade correta, pois ela influencia diretamente
a implementação relacional.

Fontes:

DATE, C. J. Introdução a Sistemas de Bancos de Dados, 8ª Ed.

Pearson. Cap. 4 e 5.
NAVATHE, S. B.; ELMASRI, R. Fundamentos de Sistemas de
Banco de Dados, 7ª Ed., Pearson. Cap. 7 e 8.
SILBERSCHATZ, Abraham et al. Sistemas de Banco de Dados, 6ª
Ed., Pearson. Cap. 2.
IBM – Entity-Relationship Modeling

22. SQL – Modelagem Física de Dados e Tipos de Dados em SQL

A modelagem física de dados é a etapa onde o projeto do banco é

traduzido em estruturas físicas concretas que serão implementadas
diretamente no SGBD. Envolve decisões de performance,
armazenamento, e a escolha adequada de tipos de dados para cada
atributo, de acordo com o SGBD utilizado (MySQL, PostgreSQL,
Oracle, SQL Server, etc.).

1. Conceito de Modelagem Física

Define como os dados serão armazenados, acessados e

manipulados no banco de dados.
 Traduz tabelas e colunas do modelo lógico em comandos CREATE
TABLE .
Considera:
Tipos de dados apropriados.
Índices.
Partições.
Constraints (restrições como NOT NULL , UNIQUE , CHECK ).
Otimizações específicas do SGBD.

2. Tipos de Dados em SQL

Os tipos de dados podem variar um pouco entre SGBDs, mas

seguem uma lógica geral. São divididos em grandes categorias:

A. Tipos Numéricos

Tipo Descrição Exemplos (MySQL)

INT Inteiro de 4 bytes INT , INTEGER , INT(11)

SMALLINT Inteiro de 2 bytes Valores até ±32.767

BIGINT Inteiro de 8 bytes Valores muito grandes (64 bits)
DECIMAL(p,s) Precisão exata, usado para DECIMAL(10,2) (ex: 99999999.99)
finanças
FLOAT Ponto flutuante (precisão Aproximado, pode causar
simples) imprecisão
DOUBLE Ponto flutuante (precisão dupla) Para cálculos científicos

⚠️ Evite FLOAT/DOUBLE para valores financeiros. Use DECIMAL.

B. Tipos de Texto (Strings)

Tipo Descrição

CHAR(n) Texto de tamanho fixo

 Tipo Descrição

VARCHAR(n) Texto de tamanho variável

TEXT Armazena grandes textos
ENUM Conjunto limitado de valores permitidos

Diferença entre CHAR e VARCHAR:

CHAR(10) : armazena sempre 10 caracteres, preenchendo com

espaços.
VARCHAR(10) : armazena só o necessário, até 10 caracteres.

C. Tipos de Data e Tempo

Tipo Descrição

DATE Somente data (AAAA-MM-DD)

TIME Somente hora (HH:MM:SS)
DATETIME Data e hora (YYYY-MM-DD HH:MM:SS)
TIMESTAMP Similar a DATETIME , mas atualizado automaticamente (ex:
CURRENT_TIMESTAMP )

D. Tipos Lógicos (Booleanos)

Tipo Descrição

BOOLEAN Verdadeiro ( TRUE ) ou Falso ( FALSE )

TINYINT(1) Usado em MySQL para simular boolean

3. Restrições (Constraints)

São usadas para garantir a integridade dos dados na modelagem

física:
 NOT NULL : valor obrigatório.
UNIQUE : valor exclusivo na coluna.
PRIMARY KEY : identifica unicamente a linha.
FOREIGN KEY : garante integridade referencial com outra tabela.
CHECK : restringe valores possíveis.
DEFAULT : valor padrão se nenhum for informado.

Exemplo:

CREATE TABLE Funcionario (

ID INT PRIMARY KEY,
Nome VARCHAR(100) NOT NULL,
Salario DECIMAL(10,2) CHECK (Salario > 0),
Ativo BOOLEAN DEFAULT TRUE,
DataContratacao DATE DEFAULT CURRENT_DATE
);

4. Boas Práticas em Modelagem Física

Escolher o tipo de dado mais restrito necessário (evita

desperdício de espaço e melhora performance).
Usar VARCHAR ao invés de TEXT , salvo para grandes textos.
Evitar FLOAT para valores que exigem precisão.
Normalizar apenas até o ponto em que não prejudique a
performance.
Usar CHECK para validações simples de integridade.

5. Diferenças entre SGBDs

MySQL aceita tipos como ENUM , SET .

PostgreSQL possui tipos mais avançados como ARRAY , JSONB .
SQL Server tem MONEY , UNIQUEIDENTIFIER , etc.
Oracle usa NUMBER , CLOB , BLOB , etc.

6. Modelagem Física vs. Lógica

 Modelagem Lógica Modelagem Física

Sem se preocupar com o SGBD Considera limitações e especificidades do

SGBD
Mais abstrata Mais próxima da implementação
Entidades, atributos, Tabelas, colunas, índices, constraints
relacionamentos

Fontes:

DATE, C. J. Introdução a Sistemas de Bancos de Dados, 8ª Ed.

Pearson. Cap. 7 e 12.
NAVATHE, S. B.; ELMASRI, R. Fundamentos de Sistemas de
Banco de Dados, 7ª Ed., Pearson. Cap. 15.
Oracle Docs: https://docs.oracle.com/en/
PostgreSQL Docs: https://www.postgresql.org/docs/
MySQL Docs: https://dev.mysql.com/doc/

23. SQL – Otimização de Consultas SQL e uso do EXPLAIN

A otimização de consultas é fundamental para garantir desempenho

e escalabilidade em sistemas de banco de dados. Consultas mal
escritas ou mal planejadas podem levar a lentidão extrema, mesmo
com hardware robusto. Nesta etapa, o uso de índices, análise de
planos de execução e boas práticas de escrita SQL é central.

1. O que é Otimização de Consultas SQL?

Consiste em reestruturar consultas SQL para que sejam executadas

mais rapidamente, consumam menos recursos e façam uso eficiente
dos índices e estruturas do banco de dados.

2. O papel do otimizador de consultas

Cada SGBD possui um query optimizer, que transforma a

consulta SQL em um plano de execução.
 O otimizador escolhe entre diferentes caminhos (acesso por
índice, varredura completa, junções aninhadas, hash joins, etc.).
A performance da consulta dependerá do plano escolhido.

3. Uso do EXPLAIN (ou EXPLAIN PLAN)

EXPLAIN permite visualizar o plano de execução que o banco usará

para rodar a consulta. Ele mostra:

A ordem das operações.

Se será usada leitura sequencial (full scan) ou índice.
O tipo de junção.
Quantas linhas o SGBD espera processar.
Custo estimado de cada operação.

Exemplo em MySQL:

EXPLAIN SELECT * FROM pedidos WHERE cliente_id = 123;

Exemplo em PostgreSQL:

EXPLAIN ANALYZE SELECT * FROM pedidos WHERE cliente_id = 123;

Saída típica:

Index Scan using idx_cliente_id on pedidos (cost=0.29..8.50

rows=1 width=100)

4. Boas práticas de Otimização

A. Uso apropriado de índices

Crie índices para colunas frequentemente usadas em:

WHERE , JOIN , ORDER BY , GROUP BY .

Índices compostos devem seguir a ordem correta de uso.

 Evite funções nas colunas indexadas (ex: WHERE UPPER(nome) =
'JOÃO' ) pois invalidam o índice.

B. Evite SELECT

Evite SELECT * , pois isso:

Retorna dados desnecessários.
Aumenta o tempo de transferência.
Impede uso de índices cobertos (covering indexes).

C. Use filtros seletivos

Filtros como WHERE status = 'ativo' são mais eficientes se o

campo estiver indexado e for seletivo (excluir muitos registros).

D. Cuidado com subconsultas correlacionadas

Evite:

SELECT nome FROM clientes WHERE id IN (

SELECT cliente_id FROM pedidos WHERE valor > 100
);

Prefira JOIN:

SELECT DISTINCT c.nome

FROM clientes c
JOIN pedidos p ON c.id = p.cliente_id
WHERE p.valor > 100;

E. Utilize LIMIT (ou FETCH FIRST) para evitar leitura total

SELECT * FROM transacoes ORDER BY data DESC LIMIT 10;

5. Operações custosas

Evite:
 LIKE '%palavra%' : impossibilita uso de índice.
OR excessivos: preferir IN .
NOT IN e NOT EXISTS : preferir LEFT JOIN ... IS NULL com
cautela.
Conversões de tipo implícitas ( id = '123' quando id é inteiro).

6. Medição real com EXPLAIN ANALYZE (PostgreSQL)

EXPLAIN ANALYZE SELECT * FROM produtos WHERE preco > 100;

Essa versão executa de fato a consulta e traz:

Tempo real de execução.

Nível de paralelismo.
Comparação entre estimado e real.

7. Ferramentas e práticas complementares

VACUUM / ANALYZE (PostgreSQL): atualiza estatísticas do

otimizador.
SHOW PROFILE (MySQL): detalha tempo gasto por etapa da
execução.
Query Plan Caching: SGBDs modernos reaproveitam planos de
execução otimizados.
Use índices parciais e índices cobridores (covering indexes)
quando possível.

8. Avaliação do Plano de Execução – Itens comuns

Campo do EXPLAIN Significado

type Tipo de acesso (ALL = full scan, ref = uso de índice)

key Qual índice será usado
rows Estimativa de linhas lidas
extra Informações adicionais (Using where, Using index, etc.)
Fontes:

Elmasri, R.; Navathe, S. B. Fundamentos de Sistemas de Banco

de Dados, 7ª Ed. Pearson. Cap. 15 e 16.
MySQL Docs – EXPLAIN:
https://dev.mysql.com/doc/refman/8.0/en/explain.html
PostgreSQL Docs – Query Planning:
https://www.postgresql.org/docs/current/using-explain.html
SQL Performance Explained – Markus Winand (2012).
Oracle Docs – EXPLAIN PLAN: https://docs.oracle.com/

24. SQL – Integridade Referencial (FOREIGN KEY e ações ON

DELETE/UPDATE)

A Integridade Referencial garante que relações entre tabelas

permaneçam consistentes, evitando registros "órfãos" e mantendo
coerência no modelo de dados. Isso é feito por meio das chaves
estrangeiras (FOREIGN KEY), que impõem restrições ao inserir,
atualizar ou deletar registros.

1. Conceito de Chave Estrangeira (FOREIGN KEY)

Uma chave estrangeira (foreign key) é um campo (ou combinação

de campos) em uma tabela que faz referência à chave primária de
outra tabela.

Exemplo:

CREATE TABLE departamentos (

id INT PRIMARY KEY,
nome VARCHAR(100)
);

CREATE TABLE funcionarios (

id INT PRIMARY KEY,
nome VARCHAR(100),
departamento_id INT,
 FOREIGN KEY (departamento_id) REFERENCES departamentos(id)
);

Neste caso, funcionarios.departamento_id só pode conter valores

que já existam em departamentos.id .

2. Ações ON DELETE e ON UPDATE

Estas cláusulas definem o comportamento do banco de dados

quando há alterações na tabela referenciada (a “pai”).

A. ON DELETE

Define o que acontece quando o registro da tabela pai é

deletado.

B. ON UPDATE

Define o que acontece quando o valor da chave primária na

tabela pai é alterado.

3. Tipos de Ações ON DELETE / ON UPDATE

Ação Descrição

CASCADE Propaga a alteração ou exclusão para a tabela filha

SET NULL Define o valor do campo estrangeiro como NULL
SET DEFAULT Define o valor do campo estrangeiro com valor padrão (default)
RESTRICT Impede a alteração se houver referência (padrão em alguns SGBDs)
NO ACTION Igual a RESTRICT, mas avaliada apenas no final da transação

Exemplo:

CREATE TABLE funcionarios (

id INT PRIMARY KEY,
nome VARCHAR(100),
departamento_id INT,
 FOREIGN KEY (departamento_id)
REFERENCES departamentos(id)
ON DELETE SET NULL
ON UPDATE CASCADE
);

Se um departamento for deletado, os funcionarios desse

departamento terão departamento_id = NULL .
Se o id de um departamento mudar, essa mudança será
propagada para a tabela funcionarios .

4. Importância da Integridade Referencial

Evita registros órfãos (filhos sem pai).

Garante consistência transacional entre tabelas relacionadas.
É implementada no nível do banco, ou seja, o SGBD garante o
cumprimento das restrições.
Melhora a legibilidade do modelo de dados, tornando-o mais fiel
ao modelo conceitual.

5. Restrições e Cuidados

Colunas envolvidas na FOREIGN KEY devem ter mesmo tipo de

dado e compatibilidade (ex: INT com INT ).
Em muitos SGBDs, é necessário índice na coluna referenciada
(geralmente a PK).
Nem todos os SGBDs suportam todas as ações (ex: SET DEFAULT
pode não estar disponível no MySQL).

6. Exemplo completo com ON DELETE e ON UPDATE

CREATE TABLE clientes (

id INT PRIMARY KEY,
nome VARCHAR(100)
);

CREATE TABLE pedidos (

 id INT PRIMARY KEY,
cliente_id INT,
FOREIGN KEY (cliente_id)
REFERENCES clientes(id)
ON DELETE CASCADE
ON UPDATE CASCADE
);

Neste exemplo:

Se um cliente for deletado, todos os seus pedidos também serão

deletados.
Se o id de um cliente for alterado, o campo cliente_id nos
pedidos será automaticamente atualizado.

Fontes:

Silberschatz, A.; Korth, H. F.; Sudarshan, S. Sistemas de Banco

de Dados, 6ª Ed., Pearson, Cap. 5 e 6.
Elmasri, R.; Navathe, S. B. Fundamentos de Sistemas de Banco
de Dados, 7ª Ed. Pearson, Cap. 4 e 5.
PostgreSQL Docs – FOREIGN KEY:
https://www.postgresql.org/docs/current/ddl-
constraints.html#DDL-CONSTRAINTS-FK
MySQL Docs – FOREIGN KEY Constraints:
https://dev.mysql.com/doc/refman/8.0/en/create-table-foreign-
keys.html
Oracle Docs – Referential Integrity: https://docs.oracle.com/

25. SQL – Arquitetura de um SGBD (Sistema de Gerenciamento de

Banco de Dados)

A arquitetura de um SGBD descreve como seus componentes

internos trabalham juntos para armazenar, recuperar, modificar e
garantir a integridade dos dados. Compreender essa estrutura é
essencial tanto para quem administra bancos quanto para quem
escreve consultas e projeta bancos com foco em desempenho.
1. Visão Geral da Arquitetura de um SGBD

A arquitetura de um SGBD é dividida em camadas ou subsistemas,

cada uma com responsabilidades específicas. Entre os principais
componentes, destacam-se:

Gerenciador de Armazenamento (Storage Manager)

Processador de Consultas (Query Processor)
Gerenciador de Transações (Transaction Manager)
Gerenciador de Buffer (Buffer Manager)
Catálogo do Sistema (System Catalog ou Metadata)
Interface de Linguagem (SQL Parser)

2. Componentes Principais
A. Gerenciador de Armazenamento (Storage Manager)

Responsável pelo acesso físico aos dados no disco, cuidando da

estrutura de arquivos, alocação de espaço, recuperação e
armazenamento eficiente.

Inclui:

Gerenciador de arquivos (File Manager): interage com o sistema

operacional.
Gerenciador de buffer (Buffer Manager): gerencia páginas entre
memória e disco.
Gerenciador de índices: localiza registros de forma rápida
usando estruturas como B-tree ou hash.
Gerenciador de autorizações: controla permissões de acesso
aos dados.

B. Processador de Consultas (Query Processor)

Interpreta e executa comandos SQL. Possui subcomponentes:

 Analisador Sintático (Parser): valida sintaticamente o SQL e gera
a árvore de análise.
Analisador Semântico: garante que as tabelas, colunas e
operações existam e façam sentido.
Otimizador de Consultas (Query Optimizer): escolhe o plano
mais eficiente para execução.
Executor de Consultas (Query Executor): executa a consulta
conforme o plano gerado.

🔍 O otimizador é um dos principais responsáveis por melhorar o

desempenho de consultas.

C. Gerenciador de Transações (Transaction Manager)

Garante que as transações sejam atômicas, consistentes, isoladas e

duráveis (ACID).

Funções:

Controle de concorrência (Concurrency Control): gerencia

acesso simultâneo aos dados.
Controle de recuperação (Recovery Manager): recupera o banco
após falhas.

Exemplo: se houver uma queda de energia durante um UPDATE , o

SGBD poderá reverter a transação para manter a integridade.

D. Gerenciador de Buffer (Buffer Pool Manager)

Controla a transferência de dados entre disco e memória RAM.

Quando uma página de dados é solicitada, ela é carregada na
memória, manipulada e eventualmente escrita de volta no disco.

Benefício: evita acessos repetidos ao disco, aumentando a

performance.

E. Catálogo do Sistema (Metadata ou Dicionário de Dados)

Contém informações sobre a estrutura do banco:

Nomes e tipos de tabelas, colunas e índices

Restrições (PK, FK, UNIQUE)
Permissões
Estatísticas usadas pelo otimizador

Cada comando SQL executado consulta o catálogo para verificar

metadados.

F. Interface de Linguagem (Interface SQL)

Permite que aplicações se comuniquem com o SGBD através da

linguagem SQL (via APIs como JDBC, ODBC, psql etc.).

3. Diagrama da Arquitetura (visão simplificada)

+-------------------------+
| Interface SQL / APIs |
+-------------------------+
↓
+-------------+
| Parser |
+-------------+
↓
+------------------------+
| Query Optimizer |
+------------------------+
↓
+------------------------+
| Query Executor |
+------------------------+
↓
+--------------------+ +-------------------+
| Transaction Manager| | Buffer Manager |
+--------------------+ +-------------------+
 ↓ ↓
+-------------------------------+
| Storage Manager |
+-------------------------------+
↓
+-------------------+
| Disco / Arquivos |
+-------------------+

4. Importância no uso prático

Otimização de desempenho: conhecer os componentes ajuda a

entender gargalos (ex: buffer, índices, otimização).
Depuração e diagnóstico: erros em queries podem ser atribuídos
ao parser, executor ou metadados.
Escalabilidade: arquiteturas eficientes permitem SGBDs mais
robustos em ambientes distribuídos.

Fontes:

Silberschatz, A.; Korth, H. F.; Sudarshan, S. Sistemas de Banco

de Dados, 6ª Ed., Pearson, Capítulo 1 e 2.
Elmasri, R.; Navathe, S. B. Fundamentos de Sistemas de Banco
de Dados, 7ª Ed., Pearson, Cap. 1 e 2.
PostgreSQL Internals:
https://wiki.postgresql.org/wiki/Inside_PostgreSQL
MySQL Internals Manual: https://dev.mysql.com/doc/internals/en/