Modulo 1.2 - SQL Essencial

1

🏗️ CREATE TABLE - Criando estruturas

O comando CREATE TABLE faz parte da DDL (Data Definition Language), o subconjunto do SQL responsavel por definir a estrutura do banco. Com ele voce cria tabelas, define colunas, tipos de dados e restricoes. E o primeiro passo antes de qualquer operacao com dados.

Tipos de dados mais usados

TEXT: Texto de tamanho variavel. Ideal para nomes, emails, descricoes.
INT / INTEGER: Numeros inteiros. Ideal para quantidades, IDs manuais, contadores.
NUMERIC(p,s): Numero com precisao decimal. Ideal para valores monetarios. Ex: NUMERIC(10,2) = ate 10 digitos, 2 decimais.
SERIAL: Inteiro auto-incrementado. Usado como chave primaria automatica.
TIMESTAMP: Data e hora. Ideal para registrar quando algo aconteceu.
BOOLEAN: Verdadeiro ou falso. Ideal para flags (ativo, verificado, etc).

Constraints (restricoes)

Ao criar uma tabela, voce define restricoes diretamente nas colunas: PRIMARY KEY identifica o registro, NOT NULL impede valores vazios, UNIQUE impede duplicatas, REFERENCES cria chave estrangeira e DEFAULT define um valor padrao.

CREATE TABLE cliente (
  id SERIAL PRIMARY KEY,
  nome TEXT NOT NULL,
  email TEXT UNIQUE
);

CREATE TABLE pedido (
  id SERIAL PRIMARY KEY,
  cliente_id INT REFERENCES cliente(id),
  total NUMERIC(10,2) NOT NULL,
  criado_em TIMESTAMP DEFAULT NOW()
);

2

➕ INSERT e UPDATE - Manipulando dados

Depois de criar a estrutura, voce precisa popular as tabelas. O INSERT adiciona novos registros e o UPDATE modifica registros existentes. Juntos com DELETE, formam as operacoes CRUD (Create, Read, Update, Delete) - a base de qualquer aplicacao.

Operacoes DML

INSERT INTO ... VALUES: Adiciona uma ou mais linhas. Voce especifica as colunas e os valores correspondentes.
INSERT multiplo: Insira varias linhas em um unico comando separando os grupos de valores por virgula.
UPDATE ... SET ... WHERE: Modifica valores de colunas em registros que atendem a condicao WHERE.

Cuidado com UPDATE sem WHERE

Um UPDATE sem clausula WHERE modifica todos os registros da tabela. Sempre inclua WHERE para limitar o escopo. Antes de executar um UPDATE, rode um SELECT com o mesmo WHERE para confirmar quais registros serao afetados.

-- Inserindo um registro
INSERT INTO cliente (nome, email)
VALUES ('Ana Silva', 'ana@example.com');

-- Inserindo multiplos registros de uma vez
INSERT INTO cliente (nome, email)
VALUES ('Carlos Lima', 'carlos@example.com'),
       ('Maria Santos', 'maria@example.com');

-- Atualizando um registro especifico
UPDATE cliente
SET email = 'ana.silva@example.com'
WHERE id = 1;

3

🔍 SELECT e WHERE - Consultando dados

O SELECT e o comando mais usado do SQL. Ele le dados das tabelas e retorna resultados filtrados, ordenados e limitados conforme voce precisa. A clausula WHERE filtra quais linhas devem aparecer no resultado.

Anatomia de um SELECT

SELECT colunas: Quais colunas retornar. Use * para todas (evite em producao).
FROM tabela: De qual tabela buscar os dados.
WHERE condicao: Filtra linhas. Aceita operadores como =, !=, >, <, LIKE, IS NULL, IN.
ORDER BY: Ordena o resultado. ASC (padrao) ou DESC.
LIMIT: Limita o numero de linhas retornadas.

Operadores logicos

Combine condicoes com AND (ambas devem ser verdadeiras), OR (pelo menos uma verdadeira) e NOT (inverte a condicao). Use parenteses para controlar a precedencia quando misturar AND e OR.

-- Selecionar colunas especificas com filtro
SELECT nome, email
FROM cliente
WHERE email IS NOT NULL;

-- Filtrar, ordenar e limitar
SELECT *
FROM pedido
WHERE total > 100
ORDER BY criado_em DESC
LIMIT 10;

-- Combinando condicoes com AND e operadores
SELECT nome
FROM cliente
WHERE email LIKE '%example.com'
  AND nome != 'Ana Silva';

4

🔗 JOINs - Combinando tabelas

No modelo relacional, dados ficam distribuidos em varias tabelas. O JOIN combina linhas de duas ou mais tabelas com base em uma condicao de relacionamento (geralmente chave estrangeira = chave primaria). E o que da poder real ao SQL.

Tipos de JOIN

INNER JOIN: Retorna apenas linhas que tem correspondencia nas duas tabelas. Se um cliente nao tem pedido, ele nao aparece.
LEFT JOIN: Retorna todas as linhas da tabela da esquerda, mesmo sem correspondencia na direita. Colunas da direita ficam NULL.
RIGHT JOIN: Inverso do LEFT. Todas da direita, mesmo sem correspondencia na esquerda.
FULL JOIN: Retorna todas as linhas de ambos os lados, com NULL onde nao ha correspondencia.

Aliases tornam tudo mais legivel

Use aliases (apelidos) para tabelas: FROM cliente c permite referenciar como c.nome em vez de cliente.nome. Isso e especialmente util quando voce junta varias tabelas e as colunas tem nomes ambiguos.

-- INNER JOIN: clientes que TEM pedidos
SELECT c.nome, p.total, p.criado_em
FROM cliente c
INNER JOIN pedido p ON p.cliente_id = c.id
ORDER BY p.total DESC;

-- LEFT JOIN: TODOS os clientes, mesmo sem pedidos
-- COALESCE substitui NULL por 0
SELECT c.nome, COALESCE(SUM(p.total), 0) AS total_gasto
FROM cliente c
LEFT JOIN pedido p ON p.cliente_id = c.id
GROUP BY c.nome;

5

📊 GROUP BY e Agregacoes - Resumindo dados

Funcoes de agregacao transformam muitas linhas em um unico resultado resumido. O GROUP BY agrupa linhas que compartilham um valor em comum, e as funcoes de agregacao operam sobre cada grupo. E assim que voce gera relatorios e estatisticas direto no SQL.

Funcoes de agregacao

COUNT(*): Conta o numero de linhas no grupo.
SUM(coluna): Soma os valores da coluna no grupo.
AVG(coluna): Calcula a media dos valores.
MIN(coluna) / MAX(coluna): Retorna o menor/maior valor.
HAVING: Filtra grupos apos a agregacao (o WHERE dos grupos). Diferente de WHERE, que filtra linhas antes do agrupamento.

WHERE vs HAVING

WHERE filtra linhas individuais antes do agrupamento. HAVING filtra grupos depois da agregacao. Exemplo: "mostre clientes que gastaram mais de R$500" usa HAVING, porque o total e calculado pelo SUM apos o GROUP BY.

-- Resumo por cliente: contagem, soma e media
SELECT cliente_id,
       COUNT(*) AS num_pedidos,
       SUM(total) AS total,
       AVG(total) AS media
FROM pedido
GROUP BY cliente_id
HAVING SUM(total) > 500;

6

🛡️ DELETE e Seguranca - Removendo com cuidado

O DELETE remove registros permanentemente. E um comando poderoso e perigoso: sem WHERE, ele apaga tudo da tabela. Na pratica, muitas aplicacoes preferem o padrao soft delete, que marca o registro como removido em vez de apaga-lo de verdade.

Estrategias de remocao

Hard delete: DELETE FROM tabela WHERE ... Remove permanentemente. Use para dados temporarios ou quando a regulacao exige.
Soft delete: Adicione uma coluna deletado_em TIMESTAMP. Em vez de deletar, faca UPDATE marcando a data. Os dados continuam no banco para auditoria.
TRUNCATE: Remove TODOS os registros de uma vez, mais rapido que DELETE, mas sem WHERE. Usado em limpezas completas.

FACA

Sempre use WHERE no DELETE
Rode SELECT antes para confirmar
Prefira soft delete em producao
Use transacoes (BEGIN/ROLLBACK)

NAO FACA

DELETE sem WHERE
TRUNCATE em tabelas de producao
Deletar sem backup recente
Ignorar chaves estrangeiras

-- SEGURO: sempre com WHERE
DELETE FROM pedido WHERE id = 5;

-- SOFT DELETE (recomendado)
-- Passo 1: adicione a coluna de controle
ALTER TABLE cliente ADD COLUMN deletado_em TIMESTAMP;

-- Passo 2: em vez de deletar, marque a data
UPDATE cliente SET deletado_em = NOW() WHERE id = 3;

-- Nas consultas, filtre os "deletados":
-- SELECT * FROM cliente WHERE deletado_em IS NULL;

💻 SQL Essencial