🚀 CAPÍTULO 20: CONCLUSÃO, ARQUITETURA POLIGLOTA E ESTUDO DE CASO

🎯 Objetivos de Aprendizagem

Ao final deste capítulo (estimativa: 2 horas de estudo autoguiado), você será capaz de:

• 🔹 Integrar todas as tecnologias do curso na disciplina de Persistência Poliglota (Polyglot Persistence).
• 🔹 Combinar o banco relacional (PostgreSQL/ACID), banco de documentos (MongoDB), cache chave-valor (Redis) e busca vetorial (pgvector) na mesma arquitetura corporativa.
• 🔹 Analisar o Estudo de Caso de ponta a ponta da TecProExpress e dos 10 Projetos Integradores.
• 🔹 Consolidar as competências de Engenharia de Dados para atuação profissional no mercado de TI.

🏢 O Cenário Corporativo (Seu Desafio)

A diretoria da TecProExpress aprovou a arquitetura final poliglota. Seu desafio é integrar PostgreSQL, MongoDB e Redis em uma solução corporativa unificada.

Nesta unidade final de engenharia de dados, nosso objetivo é aplicar todo o conhecimento acumulado em um cenário real da indústria.

Objetivo: Consolidar a visão de arquiteto de dados através da modelagem, criação e manipulação de um sistema comercial completo (SGBD Relacional).

🧠 Fundamentos: Persistência Poliglota e Arquitetura de Dados de Alta Escala O Mercado de Tecnologia

O domínio de SGBDs abre portas para as carreiras mais bem remuneradas do mercado global:

🔹 PASSO 2: Ferramenta de Elite (PostgreSQL)

Recomendamos o PostgreSQL 17 para este estudo. Ele é o banco de dados livre mais robusto e próximo dos padrões globais ANSI SQL.

🔹 Dica do Mestre: O PostgreSQL é a escolha de grandes Unicórnios devido à sua conformidade rigorosa e suporte nativo a JSON (NoSQL) dentro do ambiente Relacional.

🏢 CONTEXTUALIZAÇÃO: TecProExpress

A empresa TecProExpress solicita um sistema para gerenciar suas operações de venda. O objetivo estratégico é possuir controle total sobre o fluxo comercial.

Objetivo: Analisar requisitos de negócio, identificar entidades e definir as restrições de integridade de um cenário comercial real.

🔹 PASSO 1: Levantamento de Requisitos

Para o desenvolvimento, foram identificadas as seguintes necessidades críticas:

• 📖 Clientes: Cadastro e histórico (CNPJ/CPF, Localização).
• 📖 Produtos: Gestão de itens com preços de mercado.
• 📖 Vendedores: Controle de equipe para comissões.
• 📖 Vendas: Registro imutável de transações financeiras.

📜 Regras de Negócio (Integridade)

1. Uma Venda pertence a apenas um Cliente.
2. Uma Venda é realizada por apenas um Vendedor.
3. Uma Venda pode conter múltiplos Produtos (N:M).
4. O sistema opera em Matriz Centralizada.

🔹 PASSO 2: Identificação de Entidades

Após a análise, identificamos as seguintes tabelas lógicas:

1. 📖 CLIENTE
2. 📖 VENDEDOR
3. 📖 PRODUTO
4. 📖 VENDA
5. 📖 VENDA_ITENS (Tabela Associativa M:N)

🔹 Nota de Projeto: A entidade "Empresa" não será modelada como tabela, por ser um sistema exclusivo para uma unidade de negócio centralizada.

🗺️ MODELAGEM ER: TecProExpress

Para projetar um banco de dados de alto desempenho, mapeamos as entidades respeitando as regras de negócio.

Objetivo: Visualizar a arquitetura do banco de dados comercial através de diagramas ER e compreender a integridade referencial dos relacionamentos 1:N e N:M.

🔹 PASSO 1: Diagrama de Entidade-Relacionamento

O diagrama abaixo consolida a estrutura profissional da TecProExpress:

🔹 Arquitetura de Dados Comercial

erDiagram
    CLIENTE ||--o{ VENDA : "possui"
    VENDEDOR ||--o{ VENDA : "realiza"
    VENDA ||--|{ VENDA_ITENS : "contém"
    PRODUTO ||--o{ VENDA_ITENS : "compõe"

    CLIENTE {
        int cli_id PK
        string cli_nome
        string cli_documento
    }
    VENDEDOR {
        int ven_id PK
        string ven_nome
        decimal ven_comissao
    }
    VENDA {
        int vda_id PK
        date vda_data
        int vda_cliente_id FK
        int vda_vendedor_id FK
    }
    VENDA_ITENS {
        int vdi_venda_id PK, FK
        int vdi_sequencia PK
        int vdi_produto_id FK
        decimal vdi_quantidade
        decimal vdi_preco_venda
    }
    PRODUTO {
        int prod_id PK
        string prod_nome
        decimal prod_preco_atual
    }

🔹 PASSO 2: Análise dos Relacionamentos

1. 📖 CLIENTE x VENDA (1:N): Um cliente realiza múltiplas compras históricas.
2. 📖 VENDEDOR x VENDA (1:N): Transação creditada a um vendedor responsável.
3. 📖 VENDA x VENDA_ITENS (1:N): A venda conecta a lista de itens físicos.
4. 📖 PRODUTO x VENDA_ITENS (1:N): O produto compõe diversos carrinhos de compra.

🔹 Valor Histórico: O preço do produto no momento da venda é armazenado em VENDA_ITENS. Isso garante que mudanças futuras no preço do produto não alterem o valor de vendas passadas.

🔀 MAPEAMENTO PARA O RELACIONAL

Chegamos ao ápice da nossa jornada! Vamos aplicar o conhecimento na prática para a fábrica TecProExpress.

Objetivo: Implementar o esquema físico (DDL) e desenvolver consultas de inteligência de negócio (JOINs) para extrair faturamento e detalhes de vendas.

🔹 PASSO 1: Levantamento Estratégico

Antes de codificar, relembramos o coração do negócio:

1. 📖 PRODUTOS: Itens fabricados e preço sugerido.
2. 📖 CLIENTES: Quem consome nossos produtos profissionais.
3. 📖 VENDAS: Registro de faturamento e movimentação.
4. 📖 ITENS DA VENDA: O detalhamento técnico de cada fatura.

🔹 PASSO 2: Implementação do Esquema (DDL)

Criaremos as tabelas respeitando a Integridade Referencial:

-- 1. Tabelas Independentes
CREATE TABLE PRODUTOS (
    ID INT PRIMARY KEY,
    DESCRICAO VARCHAR(100) NOT NULL,
    VALOR_SUGERIDO DECIMAL(12,2)
);

CREATE TABLE CLIENTES (
    ID INT PRIMARY KEY,
    NOME VARCHAR(100) NOT NULL,
    ESTADO CHAR(2)
);

CREATE TABLE VENDEDOR (
    ID INT PRIMARY KEY,
    NOME VARCHAR(100) NOT NULL,
    MATRICULA VARCHAR(20) UNIQUE NOT NULL
);

-- 2. Tabela de Movimentação
CREATE TABLE VENDA (
    ID INT PRIMARY KEY,
    DATA_MOVTO DATE DEFAULT CURRENT_DATE,
    CLIENTE_ID INT,
    VENDEDOR_ID INT,
    VALOR_TOTAL DECIMAL(12,2),
    FOREIGN KEY (CLIENTE_ID) REFERENCES CLIENTES(ID),
    FOREIGN KEY (VENDEDOR_ID) REFERENCES VENDEDOR(ID)
);

-- 3. Detalhamento (Tabela Associativa)
CREATE TABLE VENDA_ITENS (
    VENDA_ID INT,
    SEQUENCIAL INT,
    PRODUTO_ID INT,
    QUANTIDADE DECIMAL(10,2),
    VALOR_UNIDADE DECIMAL(12,2), -- PREÇO HISTÓRICO
    PRIMARY KEY (VENDA_ID, SEQUENCIAL),
    FOREIGN KEY (VENDA_ID) REFERENCES VENDA(ID),
    FOREIGN KEY (PRODUTO_ID) REFERENCES PRODUTOS(ID)
);

🔹 PASSO 3: Inteligência de Negócio (SELECT)

Como extrair um relatório completo de faturamento? Usamos o JOIN:

SELECT 
    V.ID AS "Nº VENDA",
    C.NOME AS "CLIENTE",
    P.DESCRICAO AS "PRODUTO",
    VI.QUANTIDADE AS "QTD",
    VI.VALOR_UNIDADE AS "PREÇO UN.",
    (VI.QUANTIDADE * VI.VALOR_UNIDADE) AS "SUBTOTAL"
FROM VENDA V
JOIN CLIENTES C ON V.CLIENTE_ID = C.ID
JOIN VENDA_ITENS VI ON V.ID = VI.VENDA_ID
JOIN PRODUTOS P ON VI.PRODUTO_ID = P.ID;

🎯 Desafio de Especialista

Tente criar uma consulta que mostre o Faturamento Total por Estado.

SELECT C.ESTADO, SUM(V.VALOR_TOTAL) AS FATURAMENTO
FROM VENDA V
JOIN CLIENTES C ON V.CLIENTE_ID = C.ID
GROUP BY C.ESTADO
ORDER BY FATURAMENTO DESC;

🔹 Visão de Arquiteto: Note como a tabela VENDA_ITENS é o coração estrutural. Sem ela, você saberia quanto o cliente pagou, mas nunca saberia o que ele realmente levou.

🏁 CONCLUSÃO: ALÉM DO RELACIONAL

Concluir esta jornada é o sentimento de dever cumprido. O banco de dados é a base sólida para a lógica estratégica.

Reflexão Final: O banco de dados é um detalhe vital, mas a verdadeira inovação é o software que resolve problemas reais e o valor que ele gera para a sociedade.

🔹 PASSO 1: Libertando-se da "Prisão Relacional"

Ao concluir este material, você domina a integração SQL. No entanto, o engenheiro moderno deve ter senso crítico:

• 📖 NoSQL & Escalabilidade: Onde o modelo relacional encontra gargalos, o NoSQL brilha.
• 📖 Arquitetura: Escolha as ferramentas pela eficiência, não por dogmas técnicos ou preferências.

Este capítulo consolida o lado relacional da arquitetura poliglota (código executável abaixo). As demais peças — que você já implementou em laboratórios anteriores — se encaixam assim na arquitetura final da TecProExpress:

🔹 PASSO 2: A Jornada Contínua

🔹 O Caminho que se Abre

flowchart LR
    Start(("🏁 Fim do Módulo")) --> Practice["🛠️ Prática de Engenharia"]
    Practice --> LearnNoSQL["📚 Domínio NoSQL/Híbrido"]
    Practice --> Cloud["☁️ Especialização Cloud"]
    Practice --> Innovation(("🚀 Inovação Profissional"))

Desejo sucesso em sua jornada como Arquiteto(a) e Engenheiro(a) de Dados. O fim é apenas o começo.

💻 Ponte Prática: Do SQL Manual ao SQLAlchemy 2.0 ORM & NoSQL

A síntese da disciplina: a implementação completa do Sistema Comercial da TecProExpress com relacionamentos $1:N$ e $N:M$ e controle transacional ACID em Python 3.11.

🔴 1. A Abordagem Manual (Scripts Desconectados)

No modelo antigo, tabelas e dados vivem isolados em arquivos .sql, exigindo que os programadores reescrevam queries complexas e tratem integridade na mão:

-- ❌ ABORDAGEM ISOLADA: Sem tipagem, sem DTOs e com alto risco de inconsistência
INSERT INTO venda (cliente_id, vendedor_id) VALUES (1, 10);
INSERT INTO venda_itens (venda_id, produto_id, qtd, preco) VALUES (1, 50, 2, 150.00);

🟢 2. A Abordagem com SQLAlchemy 2.0 (Arquitetura Comercial Completa)

Com o SQLAlchemy 2.0, modelamos a rede de entidades (Cliente, Vendedor, Produto, Venda e ItemVenda) como um grafo de objetos com navegação bidirecional e persistência em cascata:

# ✅ ABORDAGEM MODERNA: Mapeamento Relacional Comercial Completo
from datetime import datetime, timezone
from typing import Any
from sqlalchemy import create_engine, String, Float, Integer, ForeignKey, DateTime, select
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship, Session

class Base(DeclarativeBase):
    pass

class ClienteCorpModel(Base):
    __tablename__ = "clientes_corp"
    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    nome: Mapped[str] = mapped_column(String(100), nullable=False)
    vendas: Mapped[list["VendaCorpModel"]] = relationship("VendaCorpModel", back_populates="cliente")

class ProdutoCorpModel(Base):
    __tablename__ = "produtos_corp"
    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    nome: Mapped[str] = mapped_column(String(100), nullable=False)
    preco_unitario: Mapped[float] = mapped_column(Float, nullable=False)

class VendedorCorpModel(Base):
    __tablename__ = "vendedores_corp"
    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    nome: Mapped[str] = mapped_column(String(100), nullable=False)
    matricula: Mapped[str] = mapped_column(String(20), nullable=False, unique=True)
    vendas: Mapped[list["VendaCorpModel"]] = relationship("VendaCorpModel", back_populates="vendedor")

class VendaCorpModel(Base):
    __tablename__ = "vendas_corp"
    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    cliente_id: Mapped[int] = mapped_column(ForeignKey("clientes_corp.id"), nullable=False)
    vendedor_id: Mapped[int] = mapped_column(ForeignKey("vendedores_corp.id"), nullable=False)
    data_venda: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))

    cliente: Mapped["ClienteCorpModel"] = relationship("ClienteCorpModel", back_populates="vendas")
    vendedor: Mapped["VendedorCorpModel"] = relationship("VendedorCorpModel", back_populates="vendas")
    itens: Mapped[list["VendaItemCorpModel"]] = relationship("VendaItemCorpModel", back_populates="venda", cascade="all, delete-orphan")

class VendaItemCorpModel(Base):
    """Tabela associativa N:M com atributos extras (quantidade e preço praticado)."""
    __tablename__ = "vendas_itens_corp"
    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    venda_id: Mapped[int] = mapped_column(ForeignKey("vendas_corp.id"), nullable=False)
    produto_id: Mapped[int] = mapped_column(ForeignKey("produtos_corp.id"), nullable=False)
    quantidade: Mapped[int] = mapped_column(Integer, nullable=False)
    preco_unitario_gravado: Mapped[float] = mapped_column(Float, nullable=False)

    venda: Mapped["VendaCorpModel"] = relationship("VendaCorpModel", back_populates="itens")
    produto: Mapped["ProdutoCorpModel"] = relationship("ProdutoCorpModel")

🛠️ Mini-Projeto 20 (BD): Sistema Comercial Completo com Transação ACID

Objetivo: Construir e simular a operação completa de vendas da TecProExpress, gravando cabeçalho e itens em uma única transação atômica.

📋 Pré-requisitos e Instalação

No terminal do seu ambiente virtual (PowerShell ou Bash), instale a biblioteca necessária:

pip install sqlalchemy

💻 Código Completo e Autocontido (miniprojeto_20_comercial.py)

Crie o arquivo miniprojeto_20_comercial.py e insira o código abaixo integralmente:

"""
Mini-Projeto 20: Sistema Comercial Completo com Transação ACID
Curso: GTI - Banco de Dados Relacionais e Engenharia de Software
Stack: Python 3.11+ | SQLAlchemy 2.0 | SQLite
"""
import os
from datetime import datetime, timezone
from sqlalchemy import create_engine, String, Float, Integer, ForeignKey, DateTime, select
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship, Session

# 1. Definição Declarativa do Esquema Comercial Completo
class Base(DeclarativeBase):
    pass

class ClienteCorpModel(Base):
    __tablename__ = "clientes_corp"

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    nome: Mapped[str] = mapped_column(String(100), nullable=False)
    vendas: Mapped[list["VendaCorpModel"]] = relationship("VendaCorpModel", back_populates="cliente")

class ProdutoCorpModel(Base):
    __tablename__ = "produtos_corp"

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    nome: Mapped[str] = mapped_column(String(100), nullable=False)
    preco_unitario: Mapped[float] = mapped_column(Float, nullable=False)

class VendaCorpModel(Base):
    __tablename__ = "vendas_corp"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    cliente_id: Mapped[int] = mapped_column(ForeignKey("clientes_corp.id"), nullable=False)
    data_venda: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))

    cliente: Mapped["ClienteCorpModel"] = relationship("ClienteCorpModel", back_populates="vendas")
    itens: Mapped[list["VendaItemCorpModel"]] = relationship("VendaItemCorpModel", back_populates="venda", cascade="all, delete-orphan")

class VendaItemCorpModel(Base):
    """Tabela associativa N:M com atributos extras (quantidade e preço praticado)."""
    __tablename__ = "vendas_itens_corp"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    venda_id: Mapped[int] = mapped_column(ForeignKey("vendas_corp.id"), nullable=False)
    produto_id: Mapped[int] = mapped_column(ForeignKey("produtos_corp.id"), nullable=False)
    quantidade: Mapped[int] = mapped_column(Integer, nullable=False)
    preco_unitario_gravado: Mapped[float] = mapped_column(Float, nullable=False)

    venda: Mapped["VendaCorpModel"] = relationship("VendaCorpModel", back_populates="itens")
    produto: Mapped["ProdutoCorpModel"] = relationship("ProdutoCorpModel")

# 2. Ponto de Entrada Executável
if __name__ == "__main__":
    DB_FILE = "tecpro_comercial_final.db"

    # Reset preventivo para garantir idempotência em testes repetidos
    if os.path.exists(DB_FILE):
        os.remove(DB_FILE)

    engine = create_engine(f"sqlite:///{DB_FILE}", echo=False)
    Base.metadata.create_all(bind=engine)

    print("📦 SISTEMA COMERCIAL COMPLETO (SGBD + ORM) - TECPROEXPRESS")
    print("=" * 70)

    # 1. Carga Inicial do Catálogo e Clientes
    with Session(engine) as session:
        c1 = ClienteCorpModel(id=1, nome="Supermercados Aliança Ltda")
        p1 = ProdutoCorpModel(id=101, nome="Paleteira Hidráulica 2T", preco_unitario=1850.0)
        p2 = ProdutoCorpModel(id=102, nome="Leitor de Código de Barras Zebra", preco_unitario=450.0)
        session.merge(c1)
        session.merge(p1)
        session.merge(p2)
        session.commit()

    # 2. Executando Venda Completa em Transação ACID Atômica
    with Session(engine) as session:
        with session.begin():
            nova_venda = VendaCorpModel(cliente_id=1)
            item1 = VendaItemCorpModel(produto_id=101, quantidade=2, preco_unitario_gravado=1850.0)
            item2 = VendaItemCorpModel(produto_id=102, quantidade=4, preco_unitario_gravado=450.0)
            nova_venda.itens.extend([item1, item2])
            session.add(nova_venda)

        print(f"✅ Venda #{nova_venda.id} registrada com {len(nova_venda.itens)} itens em Transação ACID!")

    # 3. Consulta da Venda com Cálculo de Total Consolidado
    print("\n🧾 FATURA COMERCIAL CONSOLIDADA:")
    with Session(engine) as session:
        venda_recuperada = session.get(VendaCorpModel, 1)
        if venda_recuperada:
            print(f"Cliente: {venda_recuperada.cliente.nome}")
            print(f"Data: {venda_recuperada.data_venda.strftime('%d/%m/%Y %H:%M')}")
            print("-" * 70)
            total_geral = 0.0
            for item in venda_recuperada.itens:
                subtotal = item.quantidade * item.preco_unitario_gravado
                total_geral += subtotal
                print(f"  • {item.produto.nome:<38} | Qtd: {item.quantidade} x R$ {item.preco_unitario_gravado:>7.2f} = R$ {subtotal:>9.2f}")
            print("-" * 70)
            print(f"💰 VALOR TOTAL DA TRANSAÇÃO: R$ {total_geral:.2f}")

    print("=" * 70)

🚀 Como Executar

Execute o script no terminal:

python miniprojeto_20_comercial.py

🖥️ Saída Esperada no Console

📦 SISTEMA COMERCIAL COMPLETO (SGBD + ORM) - TECPROEXPRESS
======================================================================
✅ Venda #1 registrada com 2 itens em Transação ACID!

🧾 FATURA COMERCIAL CONSOLIDADA:
Cliente: Supermercados Aliança Ltda
Data: 10/09/2026 10:00
----------------------------------------------------------------------
  • Paleteira Hidráulica 2T                | Qtd: 2 x R$ 1850.00 = R$   3700.00
  • Leitor de Código de Barras Zebra       | Qtd: 4 x R$  450.00 = R$   1800.00
----------------------------------------------------------------------
💰 VALOR TOTAL DA TRANSAÇÃO: R$ 5500.00
======================================================================

📚 REFERÊNCIAS BIBLIOGRÁFICAS

Fontes e acervos que fundamentaram este material técnico sobre Banco de Dados.

📚 Acervo de Referência

• 📖 Serpro. PostgreSQL: um banco de dados para todos. Disponível aqui.
• 📖 BEIGHLEY, Lynn. Use a Cabeça SQL. Alta Books, 2008.
• 📖 CARDOSO, V.; CARDOSO, G. Sistema de Banco de Dados: uma abordagem introdutória e aplicada.
• 📖 CHEN, Peter. Gerenciando Banco de Dados: A Abordagem Entidade-Relacionamento para Projeto Lógico.
• 📖 DATE, C. J. Bancos de dados: tópicos avançados.
• 📖 MongoDB. 10 things you should know about NoSQL. Disponível aqui.
• 📖 HEUSER, C. A. Projeto de banco de dados. 6. ed.
• 📖 NAVATHE, S. B.; ELMASRI, R. Sistemas de Banco de Dados. 6. ed.
• 📖 PRITCHET, E. Base: an acid alternative. Disponível aqui.
• 📖 SILBERSCHATZ, A.; KORTH, H. F.; SUDARSHAN, S. Sistema de banco de dados.
• 📖 TAURION, C. Banco de dados Open Source: presente ou futuro? IBM.
• 📖 ZHANG, J. Banco de dados na nuvem. IBM.

🔹 Aviso: As bibliografias listadas são referências clássicas. Recomenda-se a consulta das edições mais recentes para acompanhar as inovações de mercado.