🛢️ CAPÍTULO 01: INTRODUÇÃO E VISÃO GERAL DE BANCO DE DADOS

🎯 Objetivos de Aprendizagem

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

• 🔹 Diferenciar Dado bruto, Informação contextualizada e Conhecimento estratégico.
• 🔹 Compreender o papel de um Sistema Gerenciador de Banco de Dados (SGBD) e sua evolução histórica (Hierárquico, Rede, Relacional e NoSQL).
• 🔹 Dominar a Arquitetura ANSI/SPARC de 3 Níveis (Nível Externo/Visões, Nível Conceitual e Nível Interno/Físico).
• 🔹 Implementar scripts de conexão e inspeção de catálogo em Python utilizando SQLAlchemy 2.0.

Seja bem-vindo ao módulo de Banco de Dados. Aqui aprenderemos os fundamentos conceituais e a implementação prática de sistemas relacionais modernos. 🛡️🧩

🏢 O Cenário Prático (Seu Desafio)

Imagine que você é o Arquiteto de Dados Júnior da TecProExpress. A empresa estava controlando entregas e clientes usando planilhas soltas do Excel, o que estava gerando duplicações, perda de dados e lentidão.

"O seu desafio é entender os pilares dos bancos de dados profissionais para migrar toda a operação da TecProExpress das planilhas para um Sistema Gerenciador de Banco de Dados (SGBD) robusto e seguro."

🧠 Fundamentos: A Teoria Traduzida

Explore os pilares que sustentam o universo dos dados:

📊 Visão Geral do Banco de Dados

flowchart TD
    root["🛢️ Banco de Dados Corporativo"]
    
    root --> C1["🧠 Conceitos Fundamentais"]
    C1 --> C1A["SGBD e Transações ACID"]
    C1 --> C1B["Big Data & Cloud Database"]
    C1 --> C1C["Ecossistema NoSQL"]
    
    root --> C2["📐 Modelagem de Dados"]
    C2 --> C2A["MER: Modelo Entidade-Relacionamento"]
    C2 --> C2B["Modelo Relacional & Mapeamento"]
    C2 --> C2C["Normalização (1FN, 2FN, 3FN)"]
    
    root --> C3["💻 Linguagem SQL"]
    C3 --> C3A["DDL: Estrutura e Schemas"]
    C3 --> C3B["DML: Manipulação e Transações"]
    C3 --> C3C["DQL: Consultas e Agregações"]
    
    root --> C4["🏢 Estudo de Caso TecProExpress"]
    C4 --> C4A["Frota e Rastreamento"]
    C4 --> C4B["Persistência Poliglota"]
    
    style root fill:#eff6ff,stroke:#2563eb,stroke-width:2px
    style C1 fill:#f0fdf4,stroke:#16a34a
    style C2 fill:#fffbeb,stroke:#d97706
    style C3 fill:#ede7f6,stroke:#7c3aed
    style C4 fill:#fce7f3,stroke:#db2777

🔍 Detalhamento dos Conceitos:

• SGBD: "Sistema Gerenciador de Banco de Dados". É o programa que controla os dados (como o MySQL ou PostgreSQL).
• ACID: Sigla para Atomicidade, Consistência, Isolamento e Durabilidade. São as regras que impedem que uma transferência bancária seja feita pela metade se acabar a energia.
• DDL (Data Definition Language): Comandos que criam o "esqueleto" das tabelas.
• DML (Data Manipulation Language): Comandos que inserem ou alteram os dados dentro do esqueleto.

🏛️ Arquitetura de 3 Níveis (ANSI/SPARC)

Para garantir a independência de dados, os SGBDs modernos organizam as informações em três camadas fundamentais:

flowchart TD
    subgraph NivelExterno["1. Nível Externo (Visões de Usuário)"]
        V1["📱 App Mobile / Painel Vendedor<br>(View: meus_pedidos)"]
        V2["📊 BI / Diretoria Financeira<br>(View: faturamento_mensal)"]
    end

    subgraph NivelConceitual["2. Nível Conceitual (Lógica Global / Schema)"]
        NC["🗄️ Tabelas & Relacionamentos Lógicos<br>(CLIENTE, PEDIDO, PRODUTO, ITEM_PEDIDO)"]
    end

    subgraph NivelInterno["3. Nível Interno / Físico (Armazenamento)"]
        NI["💾 Índices B-Tree, Páginas de 16KB no Disco, Tablespaces e Buffers"]
    end

    V1 -->|Mapeamento Externo/Conceitual| NC
    V2 -->|Mapeamento Externo/Conceitual| NC
    NC -->|Mapeamento Conceitual/Físico| NI

💡 O Manto dos Dados: O banco de dados não é apenas um "depósito", mas a base sólida sobre a qual toda a lógica de negócio de uma empresa é construída. 🛡️

📗 Stack Tecnológica Abordada

Adotamos uma abordagem comparativa (Poliglota) para maximizar sua empregabilidade:

📖 Exemplo Guiado: A Diferença Prática (DDL -> DML)

Muitos iniciantes tentam inserir dados diretamente. Em um SGBD, precisamos seguir uma sequência lógica rígida: Primeiro a estrutura (DDL), depois os dados (DML).

🛠️ Código do Exemplo (Criar antes de Inserir)

-- PASSO 1: DDL (Criação da Tabela)
-- O 'CREATE TABLE' levanta as paredes antes de colocar os móveis.
CREATE TABLE cliente (
    id INT PRIMARY KEY,
    nome VARCHAR(100)
);

-- PASSO 2: DML (Inserção dos Dados)
-- O 'INSERT INTO' coloca os dados dentro da estrutura criada.
INSERT INTO cliente (id, nome) VALUES (1, 'TecProExpress');

🔍 Detalhamento do Código:

• CREATE TABLE cliente: Instrução DDL que avisa ao banco para reservar um espaço chamado "cliente".
• INT PRIMARY KEY: Define que a coluna "id" aceitará apenas números Inteiros e será a identificação única e obrigatória do registro.
• VARCHAR(100): Define que a coluna "nome" aceita textos de até 100 caracteres.
• INSERT INTO: Instrução DML que empurra os valores "1" e "TecProExpress" para dentro das colunas preparadas.

🛠️ Prática Obrigatória 1: Seu Primeiro Script

Cenário: A TecProExpress precisa de uma tabela para guardar o registro de seus veículos de frota.

1. Crie a tabela veiculo com as colunas placa (Texto de 7 caracteres) e modelo (Texto de 50 caracteres).
2. Insira 2 veículos de exemplo.

🚀 Script de Seed (Gabarito)

-- DDL
CREATE TABLE veiculo (
    placa VARCHAR(7) PRIMARY KEY,
    modelo VARCHAR(50)
);

-- DML
INSERT INTO veiculo (placa, modelo) VALUES ('ABC1234', 'Caminhão Mercedes');
INSERT INTO veiculo (placa, modelo) VALUES ('XYZ9876', 'Van Renault');

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

Como o desenvolvedor moderno conecta a teoria de DDL e DML à programação em Python 3.11?

🔴 1. A Abordagem Manual (Cursor e Strings SQL Soltas)

No modelo manual tradicional, enviamos comandos SQL como strings puras através de um cursor. O código fica sujeito a erros de digitação e retorna tuplas sem nomes:

# ❌ ABORDAGEM COM SQL MANUAL: Strings soltas e tuplas não tipadas
import sqlite3

conn = sqlite3.connect("frota_legada.db")
cursor = conn.cursor()

# DDL manual
cursor.execute("CREATE TABLE IF NOT EXISTS veiculo (placa TEXT PRIMARY KEY, modelo TEXT);")

# DML manual
cursor.execute("INSERT INTO veiculo VALUES ('ABC1234', 'Caminhão Volvo');")
conn.commit()

# Leitura via tupla posicional:
cursor.execute("SELECT * FROM veiculo;")
for linha in cursor.fetchall():
    print(f"Placa: {linha[0]}, Modelo: {linha[1]}") # ⚠️ Índices numéricos frágeis!

conn.close()

🟢 2. A Abordagem com SQLAlchemy 2.0 Declarative (Mapeamento ORM)

Com o SQLAlchemy 2.0, a tabela é representada como uma classe Python tipada com Mapped[...]. O SGBD é gerenciado com segurança e o objeto instanciado possui atributos nomeados:

# ✅ ABORDAGEM MODERNA COM SQLALCHEMY 2.0: Classes tipadas e sessões gerenciadas
from sqlalchemy import create_engine, String
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, Session

class Base(DeclarativeBase):
    pass

class VeiculoModel(Base):
    __tablename__ = "veiculos_frota"

    placa: Mapped[str] = mapped_column(String(7), primary_key=True)
    modelo: Mapped[str] = mapped_column(String(50), nullable=False)

    def __repr__(self) -> str:
        return f"VeiculoModel(placa='{self.placa}', modelo='{self.modelo}')"

🛠️ Mini-Projeto 01 (BD): Primeiro Schema Relacional e Persistência

Objetivo: Criar um banco de dados SQLite local, gerar as tabelas via DDL automático e persistir 3 veículos usando SQLAlchemy 2.0.

📋 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_01_bd_setup.py)

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

"""
Mini-Projeto 01: Primeiro Schema Relacional e Persistência
Curso: GTI - Banco de Dados Relacionais e Engenharia de Software
Stack: Python 3.11+ | SQLAlchemy 2.0 | SQLite
"""
import os
from sqlalchemy import create_engine, select, String
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, Session

# 1. Definição Declarativa do Schema (DDL)
class Base(DeclarativeBase):
    pass

class VeiculoModel(Base):
    __tablename__ = "veiculos_frota"

    placa: Mapped[str] = mapped_column(String(7), primary_key=True)
    modelo: Mapped[str] = mapped_column(String(50), nullable=False)

    def __repr__(self) -> str:
        return f"VeiculoModel(placa='{self.placa}', modelo='{self.modelo}')"

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

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

    # Conexão com o motor do banco de dados (SQLite local)
    engine = create_engine(f"sqlite:///{DB_FILE}", echo=False)

    # DDL Automático: Cria todas as tabelas mapeadas no modelo
    print("🏗️ [DDL] Criando schema no banco de dados...")
    Base.metadata.create_all(bind=engine)

    # DML Seguro: Inserindo dados usando Sessão do SQLAlchemy
    print("📝 [DML] Persistindo veículos na base de dados...")
    with Session(engine) as session:
        v1 = VeiculoModel(placa="BRA2E19", modelo="Scania R450 6x2")
        v2 = VeiculoModel(placa="RIO9A88", modelo="Mercedes-Benz Actros")
        v3 = VeiculoModel(placa="SPO3F44", modelo="Volkswagen Delivery 11.180")

        # Evita duplicidades na execução repetida:
        session.merge(v1)
        session.merge(v2)
        session.merge(v3)
        session.commit()

    # DQL: Consultando os dados persistidos usando sintaxe SQLAlchemy 2.0
    print("\n🔍 [DQL] Consultando frota cadastrada (SQLAlchemy 2.0):")
    with Session(engine) as session:
        stmt = select(VeiculoModel)
        veiculos = session.scalars(stmt).all()
        for v in veiculos:
            print(f"  🚛 {v}")

🚀 Como Executar

Execute o script no terminal:

python miniprojeto_01_bd_setup.py

🖥️ Saída Esperada no Console

🏗️ [DDL] Criando schema no banco de dados...
📝 [DML] Persistindo veículos na base de dados...

🔍 [DQL] Consultando frota cadastrada (SQLAlchemy 2.0):
  🚛 VeiculoModel(placa='BRA2E19', modelo='Scania R450 6x2')
  🚛 VeiculoModel(placa='RIO9A88', modelo='Mercedes-Benz Actros')
  🚛 VeiculoModel(placa='SPO3F44', modelo='Volkswagen Delivery 11.180')

💡 Checkpoint de Lógica