24/09/2026
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', '[email protected]');
-- 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: "[email protected]",
interesses: ["tecnologia", "bancos de dados"]
});
// Ler (Find)
db.usuarios.find({ interesses: "tecnologia" }).sort({ nome: 1 }).limit(10);
// Atualizar (Update)
db.usuarios.updateOne(
{ email: "[email protected]" },
{ $set: { status: "ativo" }, $push: { interesses: "sql" } }
);
// Deletar (Delete)
db.usuarios.deleteOne({ email: "[email protected]" });
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:**
```sqldatabasestablesschema 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
databasestablesschema 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.
