Quais são os tipos de dados SQL comuns e como você os escolhe?

Question

Accepted Answer

Cada coluna tem um **tipo de dado** que define o que ela armazena — números, texto, datas, booleanos, etc. Escolher o tipo correto importa para **eficiência de armazenamento, correção e desempenho**. Os tipos variam um pouco entre bancos de dados, mas as categorias são padrão.

## Tipos numéricos

```sql
INT / INTEGER          -- whole numbers (4 bytes)
BIGINT                 -- large whole numbers (8 bytes) — for IDs that grow large
SMALLINT               -- small whole numbers (save space)
DECIMAL(10,2) / NUMERIC -- EXACT decimal — use for MONEY (no rounding errors)
FLOAT / REAL / DOUBLE  -- approximate floating point — NOT for money
SERIAL / AUTO_INCREMENT -- auto-incrementing integer (for primary keys)
```

**Importante:** use **`DECIMAL`/`NUMERIC` para dinheiro** (aritmética exata), nunca `FLOAT`/`DOUBLE` (que têm erros de arredondamento que corrompem cálculos financeiros).

## Tipos de texto

```sql
VARCHAR(n)    -- variable-length text up to n chars (the common choice)
CHAR(n)       -- FIXED-length (padded) — for codes of known length (e.g. country codes)
TEXT          -- large/unlimited text (articles, descriptions)
```

`VARCHAR(n)` é o tipo de texto cotidiano; `TEXT` para conteúdo grande; `CHAR(n)` para códigos de comprimento fixo.

## Data/hora, booleano e outros

```sql
DATE           -- date only (2024-01-15)
TIME           -- time only
TIMESTAMP      -- date + time (with or WITHOUT time zone — TIMESTAMPTZ in Postgres)
BOOLEAN        -- true/false
UUID           -- universally unique identifier (good for distributed IDs)
JSON / JSONB   -- structured JSON data (JSONB in Postgres is indexed/efficient)
BLOB / BYTEA   -- binary data
```

## Por que escolher o tipo correto importa

```text
✓ Storage — smaller types use less space (INT vs BIGINT; VARCHAR vs TEXT)
✓ Correctness — DECIMAL for money (exact), proper date types for dates, BOOLEAN for flags
✓ Performance — correct types index and compare efficiently; right size = less I/O
✓ Validation — the type itself constrains what can be stored (an INT can't hold text)
✓ Time zones — use TIMESTAMPTZ for timestamps to avoid time-zone bugs
```

## Por que isso importa

Escolher tipos de dados apropriados é um aspecto fundamental do design de banco de dados que afeta **armazenamento, correção e desempenho**, portanto, entender os tipos comuns e como escolhê-los é conhecimento importante do dia a dia.

Conhecer as categorias — numérico (INT, BIGINT, DECIMAL, FLOAT), texto (VARCHAR, CHAR, TEXT), data/hora (DATE, TIMESTAMP), booleano e tipos especiais (UUID, JSON/JSONB) — é necessário para projetar tabelas corretamente.

Várias escolhas têm consequências reais dignas de compreensão: usar **`DECIMAL`/`NUMERIC` para dinheiro** em vez de `FLOAT` (uma questão crítica de correção — erros de arredondamento em ponto flutuante corrompem cálculos financeiros, um bug clássico e grave), escolher o **tamanho inteiro** correto (`BIGINT` para IDs que podem crescer além do intervalo de INT — uma preocupação real para tabelas grandes), usar tipos de **data/hora** apropriados (especialmente `TIMESTAMPTZ` com consciência de fuso horário para evitar bugs de fuso horário) e selecionar tipos de texto dimensionados apropriadamente (VARCHAR vs TEXT).

A escolha correta do tipo afeta eficiência de armazenamento (tipos menores usam menos espaço e I/O), correção (o tipo valida e representa exatamente os dados) e desempenho (tipos apropriados indexam e comparam eficientemente).

Como cada coluna requer uma escolha de tipo, e como escolhas incorretas causam problemas reais (FLOAT para dinheiro corrompendo cálculos, overflow de INT para IDs, bugs de fuso horário), entender tipos de dados SQL comuns e os princípios para escolhê-los — exatidão para dinheiro, dimensionamento apropriado, timestamps com consciência de fuso horário — é conhecimento importante e fundamental para design de banco de dados sólido que previne uma classe de problemas sutis mas graves de correção de dados e desempenho.