# 📚 Manual de Consulta Rápida: Bancos de Dados

Aqui está uma versão reestruturada, profissional e prática do seu Manual de Consulta Rápida de Bancos de Dados. Ele foi organizado como um guia de referência rápida para o dia a dia de desenvolvimento e administração de dados, cobrindo desde a modelagem até comandos práticos.

📚 Manual de Consulta Rápida: Bancos de Dados

1. Classificação e Comparativo de SGBDs

Categoria	Tipo / Modelo	Principais Exemplos	Principais Casos de Uso
Relacional (RDBMS)	Tabela (Linhas e Colunas)	PostgreSQL, MySQL, SQL Server, SQLite	Sistemas financeiros, ERPs, CRMs, dados estruturados com relações complexas
NoSQL - Documento	Documentos JSON / BSON	MongoDB, CouchDB	Catálogos de produtos, blogs, dados semiespacializados, APIs REST
NoSQL - Chave-Valor	Pares de Chave e Valor	Redis, Memcached	Caching, gerenciamento de sessões, filas de mensagens de alta velocidade
NoSQL - Colunar	Famílias de Colunas	Apache Cassandra, ScyllaDB	Análise de Big Data, logs de eventos, séries temporais de alta vazão
NoSQL - Grafos	Nós, Arestas e Propriedades	Neo4j, Amazon Neptune	Redes sociais, sistemas de recomendação, detecção de fraudes

2. Padrões de Projeto e Teoremas Fundamentais

Teorema CAP (Sistemas Distribuídos)

Em um sistema distribuído, você só pode garantir duas das três propriedades simultaneamente:

Consistência (Consistency): Todos os nós veem os mesmos dados ao mesmo tempo.
Disponibilidade (Availability): Toda requisição recebe uma resposta (sucesso ou falha).
Tolerância a Partição (Partition Tolerance): O sistema continua operando mesmo com falhas de comunicação na rede.

          Consistência (C)
             /        \
            /          \
           /     CAP    \
          /              \
Disponibilidade (A) --- Tolerância a Partição (P)

Propriedades ACID vs. BASE

ACID (Bancos Relacionais Tradicionais)

A - Atomicidade: A transação executa completamente ou é totalmente revertida (all or nothing).
C - Consistência: O banco transita apenas entre estados válidos seguindo todas as regras de integridade.
I - Isolamento: Transações concorrentes não interferem umas nas outras.
D - Durabilidade: Dados gravados após um commit persistem mesmo em falhas do sistema.

BASE (Sistemas NoSQL Distribuídos)

BA - Basically Available: O sistema garante disponibilidade, mesmo que parcialmente degradado.
S - Soft-state: O estado do sistema pode mudar ao longo do tempo sem intervenção do usuário.
E - Eventual Consistency: Os dados se tornarão consistentes em todos os nós eventualmente.

3. SQL Essencial (Cheat Sheet)

DDL — Data Definition Language (Estrutura)

SQL
-- Criar Tabela com Chave Primária e Estrangeira
CREATE TABLE usuarios (
    id SERIAL PRIMARY KEY,
    nome VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE NOT NULL,
    criado_em TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE pedidos (
    id SERIAL PRIMARY KEY,
    usuario_id INT REFERENCES usuarios(id) ON DELETE CASCADE,
    total DECIMAL(10, 2) NOT NULL,
    data_pedido TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Alterar e Modificar Tabelas
ALTER TABLE usuarios ADD COLUMN status VARCHAR(20) DEFAULT 'ativo';
DROP TABLE pedidos;

DML — Data Manipulation Language (Dados)

SQL
-- Inserir Dados
INSERT INTO usuarios (nome, email) 
VALUES ('Ana Silva', 'ana@email.com');

-- Atualizar Dados
UPDATE usuarios 
SET status = 'inativo' 
WHERE id = 1;

-- Deletar Dados
DELETE FROM usuarios WHERE status = 'inativo';

DQL — Data Query Language (Consultas)

SQL
-- Consultas Básicas com Filtro e Agregação
SELECT 
    u.nome, 
    COUNT(p.id) AS total_pedidos, 
    SUM(p.total) AS valor_total
FROM usuarios u
LEFT JOIN pedidos p ON u.id = p.usuario_id
WHERE u.status = 'ativo'
GROUP BY u.id, u.nome
HAVING SUM(p.total) > 1000.00
ORDER BY valor_total DESC
LIMIT 10;

4. NoSQL Essencial (Cheat Sheet - MongoDB)

Operações CRUD (Create, Read, Update, Delete)

JavaScript
// Criar (Insert)
db.usuarios.insertOne({
  nome: "Ana Silva",
  email: "ana@email.com",
  interesses: ["tecnologia", "bancos de dados"]
});

// Ler (Find)
db.usuarios.find({ interesses: "tecnologia" }).sort({ nome: 1 }).limit(10);

// Atualizar (Update)
db.usuarios.updateOne(
  { email: "ana@email.com" },
  { $set: { status: "ativo" }, $push: { interesses: "sql" } }
);

// Deletar (Delete)
db.usuarios.deleteOne({ email: "ana@email.com" });

5. Boas Práticas e Otimização de Performance

Índices Estratégicos:
- Crie índices em colunas utilizadas frequentemente em cláusulas WHERE, JOIN e ORDER BY.
- Evite indexar colunas com baixa cardinalidade (ex: booleans ou campos com poucos valores possíveis).
Evite SELECT *:
- Solicite apenas as colunas necessárias para reduzir tráfego de rede e uso de memória.
Normalização vs. Denormalização:
- Normalização (Até 3FN): Minimiza redundância e garante integridade (ideal para OLTP/Sistemas transacionais).
- Denormalização: Reduz a necessidade de junções complexas para leitura rápida (ideal para OLAP/Data Warehouses e NoSQL).
Paging Eficiente:
- Em vez de usar offsets altos (LIMIT 10 OFFSET 100000), prefira paginação baseada em chaves (WHERE id > 100000 LIMIT 10).

---

Este manual cobre desde comandos SQL avançados até conceitos de modelagem, segurança e transações. O objetivo é ser um guia prático para profissionais que já conhecem o básico e querem se aprofundar.

---

## 🧠 1. SQL Avançado: Além do Básico

Depois de dominar `SELECT`, `WHERE`, `INSERT`, `UPDATE` e `DELETE`, o próximo passo é entender recursos que fazem a diferença em ambientes de produção.

### 1.1 CTE (Common Table Expressions)

As CTEs permitem criar "tabelas temporárias" nomeadas dentro de uma consulta, tornando o código mais legível e modular. São especialmente úteis para substituir subconsultas complexas.

**Sintaxe básica:**
```sql
WITH nome_cte AS (
SELECT coluna1, coluna2
FROM tabela
WHERE condicao
)
SELECT *
FROM nome_cte
WHERE outra_condicao;
```

**CTE Recursiva (para dados hierárquicos):**
```sql
WITH RECURSIVE hierarquia AS (
-- Caso base: funcionários sem gerente (topo da hierarquia)
SELECT id, nome, gerente_id, 1 AS nivel
FROM funcionarios
WHERE gerente_id IS NULL

UNION ALL

-- Caso recursivo: funcionários subordinados
SELECT f.id, f.nome, f.gerente_id, h.nivel + 1
FROM funcionarios f
INNER JOIN hierarquia h ON f.gerente_id = h.id
)
SELECT * FROM hierarquia ORDER BY nivel;
```

### 1.2 Window Functions (Funções de Janela)

As funções de janela realizam cálculos em um conjunto de linhas relacionadas sem agrupá-las, permitindo rankings, médias móveis e comparações entre linhas.

| Função | Descrição | Exemplo |
| :--- | :--- | :--- |
| `ROW_NUMBER()` | Número sequencial único | `ROW_NUMBER() OVER (ORDER BY salario DESC)` |
| `RANK()` | Ranking com "pulos" para empates | `RANK() OVER (ORDER BY salario DESC)` |
| `DENSE_RANK()` | Ranking sem "pulos" | `DENSE_RANK() OVER (ORDER BY salario DESC)` |
| `NTILE(n)` | Divide em n grupos | `NTILE(4) OVER (ORDER BY salario)` |
| `LEAD()` / `LAG()` | Acessa linha seguinte/anterior | `LAG(salario) OVER (ORDER BY data)` |

**Exemplo prático – Ranking de salários por departamento:**
```sql
SELECT
nome,
departamento,
salario,
ROW_NUMBER() OVER (PARTITION BY departamento ORDER BY salario DESC) AS rank
FROM funcionarios;
```

**Exemplo – Comparar com o mês anterior:**
```sql
SELECT
mes,
vendas,
LAG(vendas) OVER (ORDER BY mes) AS vendas_mes_anterior,
vendas - LAG(vendas) OVER (ORDER BY mes) AS variacao
FROM vendas_mensais;
```

### 1.3 Stored Procedures e Triggers

**Stored Procedure** é um bloco de código SQL armazenado no banco, executado sob demanda. Ideal para lógica de negócio complexa.

```sql
CREATE PROCEDURE sp_atualizar_salario(
IN p_funcionario_id INT,
IN p_percentual DECIMAL(5,2)
)
BEGIN
UPDATE funcionarios
SET salario = salario * (1 + p_percentual / 100)
WHERE id = p_funcionario_id;
END;
```

**Trigger** é um bloco executado automaticamente em resposta a um evento (INSERT, UPDATE, DELETE).

```sql
CREATE TRIGGER trg_auditoria_salario
AFTER UPDATE ON funcionarios
FOR EACH ROW
BEGIN
INSERT INTO auditoria_salarios (funcionario_id, salario_antigo, salario_novo, data)
VALUES (OLD.id, OLD.salario, NEW.salario, NOW());
END;
```

### 1.4 Views

Uma View é uma consulta armazenada que se comporta como uma tabela virtual. Útil para simplificar consultas complexas e controlar acesso.

```sql
CREATE VIEW vw_clientes_ativos AS
SELECT c.id, c.nome, c.email, COUNT(p.id) AS total_pedidos
FROM clientes c
LEFT JOIN pedidos p ON c.id = p.cliente_id
WHERE c.ativo = 1
GROUP BY c.id, c.nome, c.email;
```

### 1.5 Índices

Índices aceleram consultas, mas exigem cuidado: em excesso, tornam `INSERT`, `UPDATE` e `DELETE` mais lentos.

```sql
-- Índice simples
CREATE INDEX idx_clientes_email ON clientes(email);

-- Índice composto
CREATE INDEX idx_pedidos_cliente_data ON pedidos(cliente_id, data_pedido);

-- Índice parcial (apenas registros relevantes)
CREATE INDEX idx_pedidos_pendentes ON pedidos(status) WHERE status = 'pendente';

-- Verificar índices de uma tabela
SHOW INDEX FROM clientes;
```

**Regra de ouro:** Indexe colunas usadas em `WHERE`, `JOIN` e `ORDER BY`. Evite indexar colunas com baixa seletividade (ex: gênero).

### 1.6 Transações

Transações garantem que um conjunto de operações seja executado como uma unidade atômica. Se algo falhar, tudo é desfeito (ROLLBACK).

```sql
BEGIN;

UPDATE contas SET saldo = saldo - 100 WHERE id = 1;
UPDATE contas SET saldo = saldo + 100 WHERE id = 2;

COMMIT;
```

**Níveis de isolamento** controlam o que uma transação pode ver de outras concorrentes:

| Nível | Dirty Read | Non-Repeatable Read | Phantom Read |
| :--- | :--- | :--- | :--- |
| `READ UNCOMMITTED` | ✅ Permite | ✅ Permite | ✅ Permite |
| `READ COMMITTED` | ❌ Impede | ✅ Permite | ✅ Permite |
| `REPEATABLE READ` | ❌ Impede | ❌ Impede | ✅ Permite |
| `SERIALIZABLE` | ❌ Impede | ❌ Impede | ❌ Impede |

---

## 🗄️ 2. Diferenças Entre os Principais SGBDs

Embora o SQL seja padronizado, cada banco tem particularidades. As diferenças mais notáveis estão em tipos de dados, sensibilidade a maiúsculas, sintaxe de `LIMIT` e aspas.

| Aspecto | MySQL/MariaDB | PostgreSQL | SQL Server | Oracle | SQLite |
| :--- | :--- | :--- | :--- | :--- | :--- |
| **Booleano** | Suporta (como int) | Suporta | Não suporta nativo | Não suporta nativo | Suporta |
| **Case-sensitive** | Não (padrão) | Sim | Não (padrão) | Sim | Sim |
| **Aspas para nomes** | Backtick (\`nome\`) | Aspas duplas ("nome") | Colchetes ([nome]) | Aspas duplas ("nome") | Aspas duplas ("nome") |
| **Limitar resultados** | `LIMIT n` | `LIMIT n` ou `FETCH FIRST n ROWS` | `TOP n` ou `OFFSET...FETCH` | `FETCH FIRST n ROWS` | `LIMIT n` |
| **Auto-incremento** | `AUTO_INCREMENT` | `SERIAL` ou `GENERATED` | `IDENTITY` | `SEQUENCE` | `AUTOINCREMENT` |
| **Concatenação** | `CONCAT()` | `||` | `+` ou `CONCAT()` | `||` | `||` |

### Comandos de linha de comando (CLI) por banco

**MySQL:**
```sql
SHOW DATABASES;
USE empresa;
SHOW TABLES;
DESCRIBE clientes;
SELECT * FROM clientes;
```

**PostgreSQL (psql):**
```sql
\l -- Lista bancos
\c empresa -- Conecta ao banco
\dt -- Lista tabelas
\d clientes -- Descreve tabela
\df -- Lista funções
\sf funcao -- Mostra definição da função
\! comando -- Executa comando do shell
```

**SQL Server (T-SQL):**
```sql
SELECT name FROM sys.databases;
USE empresa;
SELECT name FROM sys.tables;
SELECT * FROM clientes;
```

**Oracle:**
```sql
SELECT table_name FROM user_tables;
SELECT * FROM clientes;
```

**SQLite:**
```sql
.databases
.tables
.schema clientes
SELECT * FROM clientes;
```

---

## 🍃 3. NoSQL: MongoDB e Redis

### 3.1 MongoDB

MongoDB é um banco de dados orientado a documentos, ideal para dados flexíveis e escalabilidade horizontal.

**Operações básicas:**
```javascript
show dbs
use empresa
show collections

// Inserir
db.clientes.insertOne({ nome: "João", idade: 30, cidade: "Araraquara" })

// Consultar
db.clientes.find()
db.clientes.find({ idade: { $gt: 18 } })
db.clientes.find({ cidade: "Araraquara" })

// Atualizar
db.clientes.updateOne(
{ nome: "João" },
{ $set: { idade: 31 } }
)

// Deletar
db.clientes.deleteOne({ nome: "João" })
```

**Aggregation Pipeline** – para transformações complexas:
```javascript
db.pedidos.aggregate([
{ $match: { status: "pago" } },
{ $group: {
_id: "$cliente_id",
total: { $sum: "$valor" },
pedidos: { $sum: 1 }
}},
{ $sort: { total: -1 } },
{ $limit: 10 }
])
```

**Índices:**
```javascript
db.clientes.createIndex({ email: 1 })
db.produtos.createIndex({ sku: 1, "location.city": 1 })
```

### 3.2 Redis

Redis é um banco de dados em memória, extremamente rápido, usado para cache, filas e contadores.

**Estruturas de dados:**

| Tipo | Comandos | Uso |
| :--- | :--- | :--- |
| **String** | `SET`, `GET`, `INCR`, `DECR` | Cache, contadores |
| **Hash** | `HSET`, `HGET`, `HGETALL` | Perfis, objetos |
| **List** | `LPUSH`, `RPUSH`, `LPOP`, `LRANGE` | Filas, feeds |
| **Set** | `SADD`, `SMEMBERS`, `SINTER` | Tags, relacionamentos |
| **Sorted Set** | `ZADD`, `ZRANGE`, `ZRANK` | Rankings, prioridades |

**Exemplos:**
```text
SET usuario "Joao"
GET usuario
DEL usuario
EXISTS usuario
KEYS *

HSET usuario:1 nome "João" idade 30
HGETALL usuario:1

LPUSH fila "tarefa1"
RPUSH fila "tarefa2"
LRANGE fila 0 -1
```

**Pub/Sub e Streams:**
```text
PUBLISH canal "mensagem"
SUBSCRIBE canal

XADD stream * campo "valor"
XREAD COUNT 10 STREAMS stream 0
```

---

## 🛡️ 4. Segurança e Boas Práticas

### 4.1 Prevenção de SQL Injection

A defesa mais eficaz é o uso de **consultas parametrizadas** (prepared statements). Nunca concatene entradas do usuário diretamente na query.

**❌ Vulnerável:**
```sql
SELECT * FROM usuarios WHERE email = '" + email + "' AND senha = '" + senha + "';
```

**✅ Seguro (parametrizado):**
```sql
SELECT * FROM usuarios WHERE email = ? AND senha = ?;
```

**Outras defesas:**
- Valide e sanitize todas as entradas (allow-list).
- Use stored procedures (quando bem implementadas).
- Aplique o princípio do menor privilégio.
- Monitore atividades suspeitas no banco.

### 4.2 Boas Práticas de Performance

**Regras práticas para otimização**:

1. **Evite funções em colunas indexadas no WHERE:**
```sql
-- ❌ Ruim
WHERE YEAR(data_pedido) = 2024

-- ✅ Bom
WHERE data_pedido >= '2024-01-01' AND data_pedido < '2025-01-01'
```

2. **Use `UNION ALL` em vez de `UNION`** quando não precisar remover duplicatas.

3. **Prefira `EXISTS` a `IN`** para subconsultas em tabelas grandes.

4. **Evite `SELECT *`** – traga apenas as colunas necessárias.

5. **Analise o plano de execução:**
```sql
EXPLAIN ANALYZE SELECT * FROM clientes WHERE cidade = 'Araraquara';
```

6. **Mantenha estatísticas atualizadas:**
```sql
ANALYZE clientes; -- PostgreSQL
ANALYZE TABLE clientes; -- MySQL
UPDATE STATISTICS clientes; -- SQL Server
```

7. **Use paginação eficiente** (keyset pagination em vez de OFFSET em grandes datasets).

---

## 📐 5. Modelagem e Normalização

A normalização organiza os dados para minimizar redundância e evitar anomalias.

### 5.1 Formas Normais

| Forma | Regra | Exemplo de Violação |
| :--- | :--- | :--- |
| **1FN** | Cada campo deve ter valor atômico | `telefones = "11-9999, 11-8888"` |
| **2FN** | Estar em 1FN e não ter dependência parcial da chave primária | `pedido_id, produto_id, nome_produto` (nome depende só de produto_id) |
| **3FN** | Estar em 2FN e não ter dependência transitiva | `funcionario_id, departamento_id, nome_departamento` (nome depende de departamento) |

### 5.2 Quando Desnormalizar

A desnormalização é uma escolha consciente para melhorar performance de leitura, aceitando redundância controlada. É comum em:
- Data warehouses e sistemas analíticos.
- Tabelas de relatórios com agregações frequentes.
- Aplicações com consultas muito complexas e leitura intensiva.

---

## 🎯 6. Ordem de Aprendizado Recomendada

Para dominar bancos de dados de forma prática, siga esta sequência:

1. **`SELECT` → `WHERE` → `INSERT` → `UPDATE` → `DELETE`**
2. **`JOIN` → `GROUP BY` → `HAVING`**
3. **`CREATE TABLE` → `ALTER TABLE` → restrições**
4. **Índices → planos de execução**
5. **Transações → níveis de isolamento**
6. **CTEs → Window Functions**
7. **Stored Procedures → Triggers → Views**
8. **NoSQL (MongoDB → Redis)**
9. **Otimização e segurança avançada**

---

## 📌 Conclusão

Este manual cobre os principais comandos e conceitos que separam um profissional iniciante de um avançado. A chave é praticar cada tópico em um ambiente real, sempre analisando planos de execução e aplicando boas práticas de segurança.

Se quiser, posso aprofundar em algum tópico específico — como particionamento de tabelas, replicação, sharding ou tuning avançado de consultas. É só pedir! 🚀

Claro. Se você está estudando comandos de bancos de dados, aqui está uma lista prática dos principais comandos em SQL, comparando os bancos mais usados.

1. Comandos SQL fundamentais

Comando	Função	Exemplo
`CREATE DATABASE`	Cria banco	`CREATE DATABASE empresa;`
`CREATE TABLE`	Cria tabela	`CREATE TABLE clientes (...);`
`INSERT`	Insere dados	`INSERT INTO clientes ...;`
`SELECT`	Consulta dados	`SELECT * FROM clientes;`
`UPDATE`	Altera dados	`UPDATE clientes SET nome='João' WHERE id=1;`
`DELETE`	Exclui dados	`DELETE FROM clientes WHERE id=1;`
`WHERE`	Filtra resultados	`SELECT * FROM clientes WHERE idade > 18;`
`ORDER BY`	Ordena	`SELECT * FROM clientes ORDER BY nome;`
`GROUP BY`	Agrupa	`SELECT cidade, COUNT(*) FROM clientes GROUP BY cidade;`
`HAVING`	Filtra grupos	`... GROUP BY cidade HAVING COUNT(*) > 5;`
`JOIN`	Combina tabelas	`SELECT * FROM clientes JOIN pedidos ON ...;`
`ALTER TABLE`	Modifica tabela	`ALTER TABLE clientes ADD telefone VARCHAR(20);`
`DROP TABLE`	Remove tabela	`DROP TABLE clientes;`
`TRUNCATE`	Remove todos os registros	`TRUNCATE TABLE clientes;`

2. Principais bancos relacionais

MySQL / MariaDB

SHOW DATABASES;
USE empresa;
SHOW TABLES;
DESCRIBE clientes;
SELECT * FROM clientes;

PostgreSQL

\l
\c empresa
\dt
\d clientes
SELECT * FROM clientes;

Microsoft SQL Server

SELECT name FROM sys.databases;
USE empresa;
SELECT name FROM sys.tables;
SELECT * FROM clientes;

Oracle Database

SELECT table_name FROM user_tables;
SELECT * FROM clientes;

SQLite

.databases
.tables
.schema clientes
SELECT * FROM clientes;

3. Comandos de consulta muito usados

-- Selecionar colunas
SELECT nome, email FROM clientes;

-- Filtrar
SELECT * FROM clientes
WHERE cidade = 'Araraquara';

-- Vários critérios
SELECT * FROM clientes
WHERE idade >= 18 AND cidade = 'Araraquara';

-- Procurar texto
SELECT * FROM clientes
WHERE nome LIKE '%Silva%';

-- Contar registros
SELECT COUNT(*) FROM clientes;

-- Maior valor
SELECT MAX(salario) FROM funcionarios;

-- Menor valor
SELECT MIN(salario) FROM funcionarios;

-- Média
SELECT AVG(salario) FROM funcionarios;

-- Soma
SELECT SUM(salario) FROM funcionarios;

4. JOINs

-- INNER JOIN
SELECT clientes.nome, pedidos.valor
FROM clientes
INNER JOIN pedidos
ON clientes.id = pedidos.cliente_id;

-- LEFT JOIN
SELECT clientes.nome, pedidos.valor
FROM clientes
LEFT JOIN pedidos
ON clientes.id = pedidos.cliente_id;

5. Transações

Muito importantes para sistemas profissionais:

BEGIN;

UPDATE contas
SET saldo = saldo - 100
WHERE id = 1;

UPDATE contas
SET saldo = saldo + 100
WHERE id = 2;

COMMIT;

Se algo der errado:

ROLLBACK;

6. NoSQL

Além dos bancos SQL, os principais bancos NoSQL usam comandos diferentes.

MongoDB:

show dbs

use empresa

show collections

db.clientes.find()

db.clientes.find({ idade: { $gt: 18 } })

db.clientes.insertOne({
    nome: "João",
    idade: 30
})

db.clientes.updateOne(
    { nome: "João" },
    { $set: { idade: 31 } }
)

db.clientes.deleteOne({ nome: "João" })

Redis:

SET usuario "Joao"
GET usuario
DEL usuario
EXISTS usuario
KEYS *

7. Os comandos que vale a pena dominar primeiro

Para aprender banco de dados de forma prática, eu focaria nesta ordem:

SELECT → WHERE → INSERT → UPDATE → DELETE → JOIN → GROUP BY → HAVING → CREATE TABLE → ALTER TABLE → índices → transações

Isso cobre uma grande parte do SQL utilizado no desenvolvimento de aplicações.

Pesquisa neste blog

Se quiser deixar donativo

Apoie nosso projeto com uma doação

Info%%¢informática