MODULO 1.1

📖 Fundamentos e Modelagem

Entenda como dados sao organizados em tabelas, como garantir integridade e como modelar antes de escrever uma linha de SQL.

6 Topicos
30 min
Basico
Teoria + Pratica
1

📊 Modelo Relacional

O modelo relacional e a base de praticamente todos os bancos de dados que voce vai usar na carreira. Criado por Edgar F. Codd na IBM em 1970, ele organiza dados em tabelas (chamadas de relacoes) com linhas e colunas bem definidas. Cada tabela representa uma entidade do mundo real.

Conceitos fundamentais

  • Tabela (Relacao): Estrutura que armazena dados de uma entidade. Ex: cliente, pedido
  • Linha (Tupla/Registro): Uma instancia da entidade. Ex: um cliente especifico
  • Coluna (Atributo): Uma propriedade da entidade. Ex: nome, email, data_nascimento
  • Dominio: O tipo de dados que uma coluna aceita. Ex: TEXT, INTEGER, DATE

Dica pratica

Pense em uma tabela como uma planilha Excel, mas com regras rigidas: cada coluna tem um tipo, cada linha e unica, e a ordem das linhas nao importa. A grande diferenca e que no banco relacional, as regras sao impostas pelo sistema, nao pela disciplina do usuario.

-- Exemplo: tabela cliente
-- Cada linha = um cliente, cada coluna = um atributo

CREATE TABLE cliente (
  id    SERIAL PRIMARY KEY,    -- Coluna: identificador unico
  nome  TEXT NOT NULL,          -- Coluna: nome obrigatorio
  email TEXT UNIQUE             -- Coluna: email unico
);

-- Inserindo uma "tupla" (linha/registro)
INSERT INTO cliente (nome, email)
VALUES ('Ana Silva', 'ana@email.com');
2

🔑 Chaves Primarias e Estrangeiras

Chaves sao o mecanismo que da identidade aos registros e conecta tabelas entre si. A chave primaria (PK) garante que cada registro e unico. A chave estrangeira (FK) cria um vinculo entre tabelas, referenciando a PK de outra tabela.

Como funcionam

  • PRIMARY KEY: Identifica cada registro de forma unica. Nao aceita NULL nem duplicatas.
  • FOREIGN KEY: Coluna que referencia a PK de outra tabela, criando um relacionamento.
  • REFERENCES: Palavra-chave SQL que define qual tabela/coluna a FK aponta.
  • ON DELETE CASCADE: Quando o registro pai e deletado, os filhos sao removidos automaticamente.
  • Integridade referencial: Garante que toda FK aponta para um registro existente na tabela pai.

FACA

  • Use SERIAL ou UUID para PKs
  • Defina FKs com REFERENCES
  • Pense no ON DELETE antes

NAO FACA

  • Usar dados de negocio como PK (CPF muda!)
  • Ignorar FKs por "performance"
  • Usar CASCADE sem pensar
-- PK: identifica o cliente
CREATE TABLE cliente (
  id    SERIAL PRIMARY KEY,
  nome  TEXT NOT NULL,
  email TEXT UNIQUE
);

-- FK: conecta pedido ao cliente
CREATE TABLE pedido (
  id         SERIAL PRIMARY KEY,
  cliente_id INT NOT NULL REFERENCES cliente(id)
               ON DELETE CASCADE,
  total      NUMERIC(10,2) NOT NULL,
  criado_em  TIMESTAMP DEFAULT NOW()
);

-- Tentativa de inserir pedido com cliente inexistente:
-- INSERT INTO pedido (cliente_id, total) VALUES (999, 50.00);
-- ERRO: violacao de chave estrangeira!
3

✅ Restricoes de Integridade

Restricoes sao regras declarativas no schema que impedem dados invalidos de entrar no banco. Sao a ultima linha de defesa da integridade, mesmo que a aplicacao tenha bugs. O banco recusa dados que violam as restricoes.

Tipos de restricoes

  • NOT NULL: A coluna nao aceita valores nulos. Obriga o campo a ser preenchido.
  • UNIQUE: Impede valores duplicados na coluna (mas aceita multiplos NULLs).
  • CHECK: Valida que o valor atende a uma condicao. Ex: CHECK (idade >= 0)
  • DEFAULT: Define um valor padrao quando nenhum e fornecido no INSERT.

Validacao em camadas

A boa pratica e validar em multiplas camadas: frontend (UX rapida), backend (regras de negocio), e banco (ultima defesa). Nunca confie apenas na validacao do frontend. O banco e a unica camada que voce controla 100%.

CREATE TABLE produto (
  id        SERIAL PRIMARY KEY,
  nome      TEXT NOT NULL,                    -- obrigatorio
  sku       TEXT UNIQUE NOT NULL,             -- unico e obrigatorio
  preco     NUMERIC(10,2) NOT NULL
            CHECK (preco > 0),               -- deve ser positivo
  estoque   INT NOT NULL DEFAULT 0
            CHECK (estoque >= 0),            -- nao pode ser negativo
  ativo     BOOLEAN DEFAULT true              -- padrao: ativo
);

-- Tentativas que o banco REJEITA:
-- INSERT INTO produto (nome, sku, preco) VALUES ('X', 'ABC', -10);
-- ERRO: violacao de CHECK (preco > 0)

-- INSERT INTO produto (sku, preco) VALUES ('DEF', 25.00);
-- ERRO: violacao de NOT NULL (nome)
4

📐 Normalizacao (1FN a 3FN)

Normalizacao e o processo de reorganizar tabelas para eliminar redundancia e evitar anomalias. Segue etapas progressivas chamadas formas normais. Na pratica, chegar ate a 3FN resolve a maioria dos problemas.

As tres formas normais

  • 1FN (Atomicidade): Cada celula contem um valor unico e indivisivel. Nada de listas em uma coluna. Ex: em vez de telefones: "11-9999, 11-8888", crie uma tabela telefone separada.
  • 2FN (Sem dependencia parcial): Todo atributo nao-chave depende da chave primaria completa, nao de parte dela. Relevante quando a PK e composta.
  • 3FN (Sem dependencia transitiva): Nenhum atributo nao-chave depende de outro atributo nao-chave. Se A depende de B e B depende de C, mova B para sua propria tabela.

Na pratica

Tabelas nao normalizadas causam tres tipos de anomalia: insercao (nao consigo inserir um dado sem outro), atualizacao (preciso atualizar em N lugares) e exclusao (perco dados que nao queria). Normalizacao elimina as tres.

-- ANTES (nao normalizado, violando 1FN):
-- | id | nome | telefones          |
-- | 1  | Ana  | 11-9999, 11-8888   |  <- lista em uma celula!

-- DEPOIS (normalizado, 1FN):
CREATE TABLE cliente (
  id   SERIAL PRIMARY KEY,
  nome TEXT NOT NULL
);

CREATE TABLE telefone (
  id         SERIAL PRIMARY KEY,
  cliente_id INT REFERENCES cliente(id),
  numero     TEXT NOT NULL
);

-- Cada telefone e um registro separado
INSERT INTO telefone (cliente_id, numero) VALUES (1, '11-9999');
INSERT INTO telefone (cliente_id, numero) VALUES (1, '11-8888');
5

🏗️ Modelagem ER

Antes de escrever SQL, voce modela. O Diagrama Entidade-Relacionamento (ER) e a planta do banco de dados. Ele mostra quais entidades existem, quais atributos cada uma tem e como elas se relacionam.

Componentes do diagrama ER

  • Entidade: Objeto do mundo real (Cliente, Pedido, Produto). Vira tabela no banco.
  • Atributo: Propriedade da entidade (nome, preco, data). Vira coluna.
  • Relacionamento: Conexao entre entidades. Ex: Cliente faz Pedido.
  • Cardinalidade: Quantos de um lado se relacionam com o outro:
    • 1:1 - Um para um (pessoa e CPF)
    • 1:N - Um para muitos (cliente e pedidos)
    • N:N - Muitos para muitos (aluno e disciplina, precisa tabela intermediaria)

Dica pratica

Sempre modele antes de criar tabelas. Use ferramentas como dbdiagram.io, draw.io ou ate papel e caneta. Um bom diagrama ER economiza horas de refatoracao. Lembre: relacionamento N:N sempre precisa de uma tabela associativa (tabela ponte).

-- Exemplo de N:N: aluno cursa disciplina
-- Precisa de tabela associativa "matricula"

CREATE TABLE aluno (
  id   SERIAL PRIMARY KEY,
  nome TEXT NOT NULL
);

CREATE TABLE disciplina (
  id   SERIAL PRIMARY KEY,
  nome TEXT NOT NULL
);

-- Tabela ponte (resolve o N:N)
CREATE TABLE matricula (
  aluno_id      INT REFERENCES aluno(id),
  disciplina_id INT REFERENCES disciplina(id),
  semestre      TEXT NOT NULL,
  PRIMARY KEY (aluno_id, disciplina_id, semestre)
);
6

💡 Quando Usar Relacional

Banco relacional nao e a resposta para tudo. Saber quando usar e quando nao usar e tao importante quanto saber SQL. A escolha certa depende da natureza dos dados e dos requisitos do sistema.

Quando relacional e ideal

  • OLTP: Sistemas transacionais (e-commerce, ERP, bancario). Muitas escritas pequenas com integridade forte.
  • Dados estruturados: Quando o schema e bem definido e muda pouco.
  • Integridade forte: Quando erros de dados custam caro (financeiro, saude, juridico).
  • Relacoes complexas: Quando dados se conectam de formas variadas e voce precisa de JOINs.

USE RELACIONAL

  • Transacoes financeiras
  • Cadastros com regras rigidas
  • Dados com muitas relacoes
  • Relatorios SQL complexos

CONSIDERE ALTERNATIVAS

  • Logs de alto volume (use time-series)
  • Dados semi-estruturados (use documento/JSON)
  • Cache de sessao (use chave-valor)
  • Grafos sociais (use banco de grafos)

Regra de ouro

Na duvida, comece com relacional. PostgreSQL e MySQL cobrem 80% dos casos de uso. So migre para NoSQL quando tiver um problema real de escala ou formato que o relacional nao resolve bem. "Premature optimization is the root of all evil."

Resumo do Modulo 1.1

Modelo relacional: tabelas, linhas, colunas, dominios
PK identifica, FK conecta, integridade referencial protege
Restricoes (UNIQUE, NOT NULL, CHECK, DEFAULT) protegem dados
Normalizacao (1FN-3FN) elimina redundancia e anomalias
Diagrama ER: modele antes de codificar
Relacional e ideal para OLTP, dados estruturados e integridade forte