Voltar a todos os guias
Projeto de bancos de dados··5 min de leitura

Como desenhar um esquema de base de dados de raiz: passo a passo

Conceba um esquema de base de dados relacional do zero. Um passo a passo desde os requisitos até às tabelas, relações e restrições com SQL.

Requisitos tornam-se entidades, relações e um esquema SQL com chaves de cliente e encomenda
Neste guia
  1. Porquê a Conceção de Esquemas É Importante
  2. Passo 1 — Reunir Requisitos
  3. Passo 2 — Identificar Entidades
  4. Passo 3 — Definir Atributos e Tipos de Dados
  5. Passo 4 — Estabelecer Relações
  6. Passo 5 — Aplicar restrições e índices
  7. Passo 6 — Normalizar (e desnormalizar onde necessário)
  8. Referências e leitura adicional

Os exemplos de SQL utilizam PostgreSQL, a menos que outro dialeto seja mencionado. Excertos curtos pressupõem que as suas tabelas referenciadas já existem. Valide o DDL na sua base de dados de destino antes de o aplicar.

Porquê a Conceção de Esquemas É Importante

Um esquema de base de dados bem desenhado é a base de qualquer aplicação fiável. Acerte e as Consultas serão rápidas, os Dados permanecerão consistentes e as funcionalidades futuras encaixarão sem migrações dolorosas. Erre e lutará contra anomalias de Dados, desempenho lento e soluções temporárias intermináveis durante a vida do projeto.

Este guia percorre um processo de seis passos para conceber um esquema de raiz — e termina com um exemplo completo do mundo real que pode adaptar para os seus próprios projetos.

Passo 1 — Reunir Requisitos

Antes de abrir qualquer ferramenta, fale com as partes interessadas. Compreenda o que a aplicação faz, que Dados gere e como esses Dados se relacionam. Faça perguntas como:

  • Quais são as principais "coisas" que o sistema acompanha? (Utilizadores, encomendas, produtos…)
  • Que dados devem ser únicos? (Emails, SKUs, slugs …)
  • Que consultas a aplicação executará com mais frequência?
  • Existem restrições regulamentares? (GDPR, HIPAA …)
  • Qual é o volume de dados esperado nos próximos 1 a 3 anos?

Escreva as respostas — elas tornam-se a sua especificação e guiarão todas as decisões subsequentes.

Passo 2 — Identificar Entidades

Um entidade é qualquer coisa sobre a qual o sistema precisa de armazenar Dados. Cada entidade mapeia-se tipicamente para uma tabela de base de dados. Para uma plataforma de blogues, a lista inicial de entidades pode ser semelhante a:

  • Utilizador — autores e leitores
  • Publicação — artigos publicados no blogue
  • Categoria — agrupamentos para publicações (por exemplo, "React", "SQL")
  • Comentário — respostas de leitores a publicações
  • Etiqueta — etiquetas de granularidade fina (muitos-para-muitos com publicações)

Esboce estes como caixas num quadro branco ou utilize o Construtor ERD para discutir o modelo conceptual antes de escolher os tipos de coluna.

Passo 3 — Definir Atributos e Tipos de Dados

Para cada entidade, liste os atributos de que necessita e escolha o tipo de dados SQL mais apropriado. Seja o mais específico possível — prefira VARCHAR(255) sobre TEXT quando conhece o comprimento máximo e prefere TIMESTAMPTZ sobre TIMESTAMP quando os fusos horários são importantes.

-- Users
id          SERIAL PRIMARY KEY
username    VARCHAR(50)  NOT NULL UNIQUE
email       VARCHAR(255) NOT NULL UNIQUE
password_hash TEXT      NOT NULL          -- store a password hash, never plaintext
bio         TEXT
avatar_url  VARCHAR(500)
created_at  TIMESTAMPTZ  DEFAULT now()

-- Posts
id          SERIAL PRIMARY KEY
author_id   INT          NOT NULL          -- FK → users.id
category_id INT                            -- FK → categories.id
title       VARCHAR(200) NOT NULL
slug        VARCHAR(220) NOT NULL UNIQUE
body        TEXT         NOT NULL
status      VARCHAR(20)  DEFAULT 'draft'   -- draft | published | archived
published_at TIMESTAMPTZ
created_at  TIMESTAMPTZ  DEFAULT now()
updated_at  TIMESTAMPTZ  DEFAULT now()

Passo 4 — Estabelecer Relações

Determine como as entidades se relacionam entre si. Os três tipos fundamentais são:

  • Um-para-Muitos (1:N) — Um utilizador tem muitas publicações; uma publicação pertence a um utilizador.
  • Muitos-para-Muitos (M:N) — Uma publicação pode ter muitas etiquetas; uma etiqueta pode pertencer a muitas publicações. Isto requer uma tabela de junção.
  • Um-para-Um (1:1) — Um utilizador tem um perfil. Frequentemente fundido numa única tabela, a menos que os dados do perfil sejam grandes ou raramente acedidos.
-- Junction table for the posts ↔ tags many-to-many relationship
CREATE TABLE post_tags (
    post_id INT NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    tag_id  INT NOT NULL REFERENCES tags  (id) ON DELETE CASCADE,
    PRIMARY KEY (post_id, tag_id)
);

Passo 5 — Aplicar restrições e índices

As restrições protegem a qualidade dos dados. No mínimo, deve considerar:

  • NOT NULL em cada coluna que tem de ter um valor.
  • UNIQUE em identificadores naturais (e-mails, slugs, nomes de utilizador).
  • CHECK restrições para regras de domínio (ex: o estado deve ser um de três valores).
  • DEFAULT valores para colunas de carimbos de data/hora e estado.
  • Chaves estrangeiras com explícito ON DELETE ações.

Depois adicione índices em colunas que vai filtrar, ordenar ou juntar frequentemente. As colunas de chave estrangeira são candidatas ideais.

-- Index foreign-key columns for faster joins
CREATE INDEX idx_posts_author   ON posts (author_id);
CREATE INDEX idx_posts_category ON posts (category_id);
CREATE INDEX idx_comments_post  ON comments (post_id);

-- Partial index: only published posts (PostgreSQL)
CREATE INDEX idx_posts_published
    ON posts (published_at DESC)
    WHERE status = 'published';

Passo 6 — Normalizar (e desnormalizar onde necessário)

Normalização elimina dados redundantes ao organizar colunas e tabelas de acordo com um conjunto de "formas normais". A maioria dos esquemas deve atingir Terceira Forma Normal (3NF):

  • 1NF — cada coluna contém valores atómicos; sem grupos repetidos.
  • 2NF — nenhum atributo não principal depende apenas de parte de uma chave candidata.
  • 3NF — cada dependência não trivial tem um determinante de superchave ou um atributo dependente que pertence a uma chave candidata.

Após a normalização, poderá seletivamente desnormalizar para desempenho — por exemplo, armazenar um comment_count no posts tabela para evitar um dispendioso COUNT(*) em cada carregamento de página. Desnormalize deliberadamente e documente-o.

Esquema Completo de Plataforma de Blog

-- Full SQL for the blog platform schema

CREATE TABLE users (
    id          SERIAL       PRIMARY KEY,
    username    VARCHAR(50)  NOT NULL UNIQUE,
    email       VARCHAR(255) NOT NULL UNIQUE,
    password_hash TEXT      NOT NULL,
    bio         TEXT,
    avatar_url  VARCHAR(500),
    created_at  TIMESTAMPTZ  DEFAULT now()
);

CREATE TABLE categories (
    id   SERIAL       PRIMARY KEY,
    name VARCHAR(100) NOT NULL UNIQUE,
    slug VARCHAR(110) NOT NULL UNIQUE
);

CREATE TABLE posts (
    id           SERIAL       PRIMARY KEY,
    author_id    INT          NOT NULL REFERENCES users (id),
    category_id  INT          REFERENCES categories (id) ON DELETE SET NULL,
    title        VARCHAR(200) NOT NULL,
    slug         VARCHAR(220) NOT NULL UNIQUE,
    body         TEXT         NOT NULL,
    status       VARCHAR(20)  NOT NULL DEFAULT 'draft'
                     CHECK (status IN ('draft','published','archived')),
    published_at TIMESTAMPTZ,
    created_at   TIMESTAMPTZ  DEFAULT now(),
    updated_at   TIMESTAMPTZ  DEFAULT now()
);

CREATE TABLE tags (
    id   SERIAL       PRIMARY KEY,
    name VARCHAR(60)  NOT NULL UNIQUE
);

CREATE TABLE post_tags (
    post_id INT NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    tag_id  INT NOT NULL REFERENCES tags  (id) ON DELETE CASCADE,
    PRIMARY KEY (post_id, tag_id)
);

CREATE TABLE comments (
    id         SERIAL      PRIMARY KEY,
    post_id    INT         NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    user_id    INT         NOT NULL REFERENCES users (id),
    body       TEXT        NOT NULL,
    created_at TIMESTAMPTZ DEFAULT now()
);

-- Indexes
CREATE INDEX idx_posts_author    ON posts    (author_id);
CREATE INDEX idx_posts_category  ON posts    (category_id);
CREATE INDEX idx_comments_post   ON comments (post_id);
CREATE INDEX idx_comments_user   ON comments (user_id);

Cole o esquema completo no Editor SQL para ERD para inspecionar as suas relações. Utilize o Construtor ERD para um desenho conceptual e uma conversão SQL revista.

Referências e leitura adicional

Mais publicações