📑 CHEATSHEETS DE ENGENHARIA E BANCO DE DADOS

Este guia reúne as sintaxes e comandos mais utilizados no dia a dia do desenvolvimento backend corporativo, servindo como material oficial de consulta rápida para laboratórios práticos, avaliações e desenvolvimento de Projetos Integradores. ⚡🛡️

🧱 1. SQLAlchemy 2.0 (CRUD & Consultas Modernas)

flowchart LR
    S["select(Model)"] --> W[".where(...)"]
    W --> J[".join(...)"]
    J --> O[".order_by(...)"]
    E["session.scalars(...).all()"]
    
    S --> W
    W --> J
    J --> O
    O --> E
    
    style S fill:#e3f2fd,stroke:#1565c0
    style W fill:#fff8e1,stroke:#f57f17
    style J fill:#e8f5e9,stroke:#2e7d32
    style O fill:#f3e5f5,stroke:#7b1fa2
    style E fill:#e0f2f1,stroke:#00695c

📋 Mapeamento Declarativo de Modelos:

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
from sqlalchemy import String, Integer, ForeignKey, Numeric
from decimal import Decimal

class Base(DeclarativeBase):
    pass

class Cliente(Base):
    __tablename__ = "clientes"
    id_cliente: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    nome: Mapped[str] = mapped_column(String(100), nullable=False)
    limite_credito: Mapped[Decimal] = mapped_column(Numeric(10, 2), default=Decimal("0.00"))
    pedidos: Mapped[list["Pedido"]] = relationship(back_populates="cliente", cascade="all, delete-orphan")

🔍 Operações de CRUD:

from sqlalchemy import select, func
from sqlalchemy.orm import selectinload

# 1. READ (Buscar por ID):
cliente = session.get(Cliente, 1)

# 2. READ (Filtrar múltiplos com WHERE e ORDER BY):
stmt = select(Cliente).where(Cliente.limite_credito > 1000).order_by(Cliente.nome.asc())
clientes = session.scalars(stmt).all()

# 3. READ (Com Eager Loading de Relacionamento):
stmt = select(Cliente).options(selectinload(Cliente.pedidos)).where(Cliente.id_cliente == 1)
cliente_com_pedidos = session.scalars(stmt).first()

# 4. CREATE (Inserir novo registro):
novo = Cliente(nome="Transportadora VIP", limite_credito=Decimal("5000.00"))
session.add(novo)
session.commit()
session.refresh(novo) # Popula o ID gerado

# 5. UPDATE (Atualizar campos):
cliente.limite_credito = Decimal("7500.00")
session.commit()

# 6. DELETE (Excluir registro):
session.delete(cliente)
session.commit()

# 7. AGGREGATE (Contagem e Média):
stmt = select(func.count(Cliente.id_cliente), func.avg(Cliente.limite_credito))
total, media = session.execute(stmt).one()

🌐 2. Flask 3.x & SQLAlchemy 2.0 (Rotas, Blueprints e JSON)

from flask import Flask, Blueprint, request, jsonify
from pydantic import BaseModel, Field
from sqlalchemy.orm import Session
from sqlalchemy import select

app = Flask(__name__)
bp = Blueprint("clientes", __name__, url_prefix="/api")

# Schema Pydantic de Entrada (Validação de Tipos)
class ClienteCreate(BaseModel):
    nome: str = Field(..., min_length=3, max_length=100)
    limite_credito: float = Field(0.0, ge=0.0)

# Rota POST (Criar registro com Validação Pydantic)
@bp.post("/clientes")
def criar_cliente():
    dados = request.get_json() or {}
    try:
        payload = ClienteCreate(**dados)
    except Exception as err:
        return jsonify({"detail": str(err)}), 400

    with SessionLocal() as session:
        cliente = Cliente(**payload.model_dump())
        session.add(cliente)
        session.commit()
        session.refresh(cliente)
        return jsonify({
            "id_cliente": cliente.id_cliente,
            "nome": cliente.nome,
            "limite_credito": float(cliente.limite_credito)
        }), 201

# Rota GET (Buscar por ID com Tratamento de Erro 404)
@bp.get("/clientes/<int:id_cliente>")
def buscar_cliente(id_cliente: int):
    with SessionLocal() as session:
        cliente = session.get(Cliente, id_cliente)
        if not cliente:
            return jsonify({"detail": "Cliente não encontrado."}), 404
        return jsonify({
            "id_cliente": cliente.id_cliente,
            "nome": cliente.nome,
            "limite_credito": float(cliente.limite_credito)
        }), 200

app.register_blueprint(bp)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

🛢️ 3. SQL Corporativo (DML, DQL e Relatórios)

📋 Ordem Obrigatória de Execução da Consulta:

1. FROM & JOIN (Localiza as tabelas)
2. WHERE (Filtra linhas individuais)
3. GROUP BY (Agrupa dados)
4. HAVING (Filtra grupos calculados)
5. SELECT (Projeta colunas e funções)
6. ORDER BY (Ordena o resultado)
7. LIMIT & OFFSET (Pagina os dados)

💻 Queries de Alto Desempenho:

-- 1. INNER JOIN (Relatório com 2 tabelas):
SELECT p.id_pedido, c.nome, p.valor_total
FROM pedido p
INNER JOIN cliente c ON p.id_cliente = c.id_cliente
WHERE p.status = 'CONCLUIDO';

-- 2. LEFT JOIN (Encontrar clientes que NUNCA compraram):
SELECT c.id_cliente, c.nome
FROM cliente c
LEFT JOIN pedido p ON c.id_cliente = p.id_cliente
WHERE p.id_pedido IS NULL;

-- 3. GROUP BY + HAVING (Categorias com faturamento > R$ 10.000):
SELECT categoria, COUNT(*) AS total_itens, SUM(preco) AS faturamento
FROM produto
GROUP BY categoria
HAVING SUM(preco) > 10000
ORDER BY faturamento DESC;

-- 4. Subquery com EXISTS (Mais rápida que IN):
SELECT nome FROM fornecedor f
WHERE EXISTS (
    SELECT 1 FROM materia_prima mp 
    WHERE mp.id_fornecedor = f.id_fornecedor AND mp.estoque_atual < 10
);

-- 5. INSERT com RETURNING (Retorna ID gerado sem segundo SELECT):
INSERT INTO clientes (nome, limite_credito) 
VALUES ('Logística Express', 3000.00) 
RETURNING id_cliente, nome;

🐳 4. Git & Docker Compose (Terminal do Desenvolvedor)