Criando seu primeiro banco de dados e tabela

1. Preparando o ambiente: conectando ao PostgreSQL

1.1. Acessando o terminal e iniciando o psql

Antes de criar qualquer banco de dados, você precisa acessar o PostgreSQL. No terminal do seu sistema operacional, digite:

psql -U postgres

Este comando conecta ao PostgreSQL com o usuário postgres. Se for solicitada uma senha, utilize aquela definida durante a instalação.

1.2. Comandos básicos de navegação: \l, \c, \dt

Uma vez dentro do psql, você pode navegar pelos bancos existentes:

\l

O comando \l lista todos os bancos de dados disponíveis no servidor.

Para conectar a um banco específico:

\c nome_do_banco

E para listar as tabelas do banco atual:

\dt

1.3. Verificando a versão e usuário atual

Para confirmar a versão do PostgreSQL e o usuário conectado:

SELECT version();
SELECT current_user;

Você verá algo como:

PostgreSQL 16.1 on x86_64-pc-linux-gnu
postgres

2. Criando seu primeiro banco de dados

2.1. Sintaxe do comando CREATE DATABASE

A sintaxe básica para criar um banco de dados é:

CREATE DATABASE nome_do_banco;

2.2. Escolhendo um nome e boas práticas de nomenclatura

Ao nomear seu banco de dados, siga estas boas práticas:
- Use letras minúsculas (PostgreSQL é case-sensitive para identificadores sem aspas)
- Substitua espaços por underscores (_)
- Evite palavras reservadas do SQL
- Escolha nomes descritivos, como escola, biblioteca, sistema_clientes

Exemplo prático:

CREATE DATABASE escola;

2.3. Verificando a criação com \l e conectando ao novo banco

Após executar o comando, verifique se o banco foi criado:

\l

Você verá escola na lista. Agora conecte-se a ele:

\c escola

A saída será:

Você agora está conectado ao banco de dados "escola".

3. Entendendo o conceito de tabela e esquema

3.1. O que é uma tabela em um banco relacional

Uma tabela é a estrutura fundamental de armazenamento em bancos relacionais. Ela organiza dados em linhas (registros) e colunas (campos). Pense nela como uma planilha do Excel, mas com regras mais rigorosas.

3.2. Diferença entre banco de dados, esquema e tabela

  • Banco de dados: contêiner que agrupa esquemas, tabelas e outros objetos
  • Esquema: subdivisão lógica dentro do banco (ex: public é o esquema padrão)
  • Tabela: estrutura que armazena os dados propriamente ditos

A hierarquia é: Banco de Dados → Esquema → Tabela

3.3. O papel das colunas e linhas (registros)

Cada coluna representa um atributo (ex: nome, idade), enquanto cada linha representa um registro completo (ex: um aluno específico).

4. Criando sua primeira tabela com CREATE TABLE

4.1. Sintaxe completa: CREATE TABLE nome (colunas)

CREATE TABLE nome_da_tabela (
    nome_coluna1 tipo_dado restricoes,
    nome_coluna2 tipo_dado restricoes,
    ...
);

4.2. Definindo colunas com nome, tipo e restrições (ex: NOT NULL)

Cada coluna precisa de:
- Nome: identificador único dentro da tabela
- Tipo: define que tipo de dado será armazenado
- Restrições: regras adicionais (opcionais)

4.3. Exemplo prático: tabela alunos com id, nome, data_nascimento

CREATE TABLE alunos (
    id SERIAL PRIMARY KEY,
    nome VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE NOT NULL,
    data_nascimento DATE NOT NULL,
    ativo BOOLEAN DEFAULT TRUE
);

5. Tipos de dados essenciais para sua primeira tabela

5.1. SERIAL para chaves primárias auto-incrementais

SERIAL cria automaticamente uma sequência que incrementa a cada nova linha. É ideal para chaves primárias numéricas que não precisam ser definidas manualmente.

id SERIAL PRIMARY KEY

5.2. VARCHAR e TEXT para textos de tamanho variável

  • VARCHAR(n): texto com limite máximo de n caracteres (ex: VARCHAR(100))
  • TEXT: texto sem limite de tamanho (até 1 GB)

Use VARCHAR quando souber o tamanho máximo; use TEXT para campos longos como descrições.

5.3. DATE, INTEGER e BOOLEAN — quando usar cada um

  • DATE: armazena data (ano, mês, dia) — use para nascimento, cadastro
  • INTEGER: números inteiros (de -2^31 a 2^31-1) — use para idade, quantidade
  • BOOLEAN: verdadeiro ou falso — use para status (ativo/inativo)

6. Adicionando restrições e chaves primárias

6.1. PRIMARY KEY: identificador único de cada linha

A chave primária garante que cada linha seja única e não nula. Pode ser definida na coluna ou ao final:

-- Na coluna
id SERIAL PRIMARY KEY

-- Ou ao final
PRIMARY KEY (id)

6.2. NOT NULL: garantindo que campos obrigatórios sejam preenchidos

Impede valores nulos em colunas essenciais:

nome VARCHAR(100) NOT NULL

6.3. UNIQUE e DEFAULT: evitando duplicatas e valores padrão

  • UNIQUE: garante que não haja valores repetidos na coluna
  • DEFAULT: define um valor padrão quando nenhum é informado
email VARCHAR(150) UNIQUE NOT NULL,
ativo BOOLEAN DEFAULT TRUE

7. Verificando e descrevendo sua tabela

7.1. Usando \d nome_tabela para ver estrutura

\d alunos

A saída mostrará:

                        Tabela "public.alunos"
    Coluna       |          Tipo          | Modificações
-----------------+------------------------+--------------
 id              | integer                | not null default nextval('alunos_id_seq'::regclass)
 nome            | character varying(100) | not null
 email           | character varying(150) | not null
 data_nascimento | date                   | not null
 ativo           | boolean                | default true
Índices:
    "alunos_pkey" PRIMARY KEY, btree (id)
    "alunos_email_key" UNIQUE CONSTRAINT, btree (email)

7.2. Listando todas as tabelas com \dt

\dt

7.3. Consultando informações do catálogo com SELECT * FROM information_schema.columns

SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'alunos';

8. Erros comuns e boas práticas ao criar tabelas

8.1. Esquecer ponto e vírgula e outros erros de sintaxe

O erro mais comum é esquecer o ponto e vírgula (;) ao final do comando. O PostgreSQL ficará esperando mais entrada. Digite ; para finalizar ou \q para sair.

Outro erro frequente é usar aspas simples em vez de aspas duplas em identificadores.

8.2. Conflitos de nome: tabelas e colunas reservadas

Evite nomes como user, order, group, select — são palavras reservadas do SQL. Se precisar usá-las, coloque entre aspas duplas:

CREATE TABLE "order" (...);

8.3. Planejamento antecipado: normalização e tipos adequados

Antes de criar sua tabela:
- Planeje os campos necessários
- Escolha tipos de dados adequados (não use TEXT para campos pequenos)
- Pense nas relações futuras entre tabelas
- Aplique normalização básica para evitar redundância

Conclusão

Você acabou de criar seu primeiro banco de dados e tabela no PostgreSQL. Dominar os comandos CREATE DATABASE e CREATE TABLE é o primeiro passo para construir sistemas robustos de armazenamento de dados. Pratique criando novas tabelas, experimente diferentes tipos e restrições, e logo estará pronto para explorar relacionamentos entre tabelas e consultas mais complexas.

Referências