Feature/transacoes datas

aprendizado/modulo2_groupby.md

@@ -0,0 +1,114 @@
+# Módulo 2 — GROUP BY e Funções Agregadas
+
+> Continuação do caderno de SQL. Preencher conforme avança nos estudos.
+
+---
+
+## 1. O que é agregação
+
+Transforma **várias linhas** de um grupo em **um único valor** de resumo.
+
+| Função | O que faz |
+|--------|-----------|
+| `COUNT(*)` | conta linhas (inclui nulas) |
+| `COUNT(col)` | conta valores não-nulos da coluna |
+| `SUM(col)` | soma |
+| `AVG(col)` | média |
+| `MIN(col)` / `MAX(col)` | mínimo / máximo |
+
+---
+
+## 2. GROUP BY — particiona o conjunto em subconjuntos
+
+Quebra a tabela em grupos pela(s) coluna(s) indicada. **Toda coluna do SELECT que não é agregada PRECISA estar no GROUP BY.**
+
+```sql
+SELECT COD_CLIENTE, COUNT(*) AS qtd_contas
+FROM contas
+GROUP BY COD_CLIENTE;
+```
+
+Esquema (teoria dos conjuntos): o conjunto total é particionado em subconjuntos disjuntos por `COD_CLIENTE`.
+
+---
+
+## 3. WHERE vs HAVING (revisão da ordem de execução)
+
+- `WHERE` filtra **linhas** ANTES de agrupar (não aceita agregação).
+- `HAVING` filtra **grupos** DEPOIS de agrupar (aceita agregação).
+
+```sql
+SELECT COD_CLIENTE, COUNT(*) AS qtd
+FROM contas
+WHERE TIPO_CONTA = 'PF'
+GROUP BY COD_CLIENTE
+HAVING COUNT(*) > 1;
+```
+
+---
+
+## 4. Exemplos no Banvic (já validados)
+
+> Sintaxe Databricks/Spark SQL. Colunas em MAIÚSCULAS (igual ao schema).
+> Mais exemplos em `Módulo 0 - Banco de Dados BanVic/banvic_queries.md`.
+
+**GROUP BY simples — saldo médio por UF:**
+```sql
+SELECT l.UF,
+       COUNT(*)                     AS NUM_CONTAS,
+       ROUND(AVG(c.SALDO_TOTAL), 2) AS SALDO_MEDIO
+FROM erp_banvic.contas c
+JOIN erp_banvic.clientes cl ON cl.COD_CLIENTE = c.COD_CLIENTE
+JOIN erp_banvic.localidades l ON l.COD_LOCALIDADE = cl.COD_LOCALIDADE
+GROUP BY l.UF
+ORDER BY SALDO_MEDIO DESC;
+```
+
+**WHERE (linhas) vs HAVING (grupo) — clientes com mais de 1 conta:**
+```sql
+SELECT COD_CLIENTE, COUNT(*) AS QTD_CONTAS
+FROM erp_banvic.contas
+WHERE TIPO_CONTA = 'PF'        -- filtra LINHAS antes de agrupar
+GROUP BY COD_CLIENTE
+HAVING COUNT(*) > 1;            -- filtra o GRUPO depois de agrupar
+```
+
+**COUNT(*) vs COUNT(col) — FK órfã (conta sem cliente):**
+```sql
+SELECT COUNT(*)                AS total_linhas,
+       COUNT(COD_CLIENTE)      AS com_cliente
+FROM erp_banvic.contas;
+-- diferença = contas com COD_CLIENTE nulo (COUNT(col) ignora nulos)
+```
+
+**Agregação + GROUP BY — volume de transações por tipo:**
+```sql
+SELECT NOME_TRANSACAO,
+       COUNT(*)                       AS QTD,
+       ROUND(SUM(VALOR_TRANSACAO), 2) AS TOTAL
+FROM erp_banvic.transacoes
+GROUP BY NOME_TRANSACAO
+ORDER BY QTD DESC;
+```
+
+## 5. Exercícios para praticar
+
+- [x] Total de contas por `TIPO_CONTA`
+- [ ] Saldo médio por agência (`contas` + `agencias`)
+- [x] Clientes com mais de 1 conta (`HAVING COUNT(*) > 1`)
+- [x] Soma de `VALOR_TRANSACAO` por `NOME_TRANSACAO` (tabela `transacoes`)
+
+---
+
+## 5. Window Functions (próximo após agregações)
+
+`FUNCAO() OVER (PARTITION BY ... ORDER BY ...)` — calcula sobre uma "janela" sem
+colapsar as linhas. Ex: `ROW_NUMBER()`, `RANK()`, `SUM() OVER (...)`.
+
+---
+
+## Checklist
+- [x] Escrever GROUP BY simples (saldo médio por UF)
+- [x] Usar HAVING com agregação (clientes c/ >1 conta)
+- [x] Diferenciar COUNT(*) de COUNT(col) (FK órfã)
+- [ ] Primeira Window Function no Banvic (ver `RANK() OVER` em banvic_queries.md)

aprendizado/modulo2_sql.md

@@ -0,0 +1,138 @@
+# Módulo 2 — SQL: Caderno de Estudos
+
+> Notas vivas do Módulo 2 (Consultando dados com SQL). Atualizar a cada conceito novo.
+> Referência prática: banco fictício **Banvic** (tabelas em `seeds/banvic/`).
+
+---
+
+## 1. Aliases (renomeação / apelidos)
+
+A sintaxe é sempre `objeto apelido` (o `AS` é opcional).
+
+| Onde | Exemplo | Efeito |
+|------|---------|--------|
+| **Tabela** (FROM/JOIN) | `FROM contas c` | apelida a tabela para referenciar colunas |
+| **Coluna** (SELECT) | `c.SALDO_TOTAL AS saldo` | renomeia a **saída** exibida |
+| **CTE** | `WITH contas_pf AS (SELECT ...)` | nomeia uma subquery inteira |
+| **Subquery** (FROM) | `FROM (SELECT ...) t` | tabela derivada precisa de apelido |
+
+Exemplo Banvic (CTE + tabela + coluna):
+```sql
+WITH contas_ativas AS (
+    SELECT NUM_CONTA, COD_CLIENTE, SALDO_TOTAL
+    FROM contas
+    WHERE SALDO_TOTAL > 0
+)
+SELECT ca.NUM_CONTA                              AS num_conta,
+       cl.PRIMEIRO_NOME || ' ' || cl.ULTIMO_NOME AS nome_cliente,
+       ca.SALDO_TOTAL                            AS saldo
+FROM contas_ativas ca
+INNER JOIN clientes cl
+    ON cl.COD_CLIENTE = ca.COD_CLIENTE
+ORDER BY ca.SALDO_TOTAL DESC;
+```
+> `||` é o operador de concatenação no Databricks/Spark SQL.
+
+---
+
+## 2. Ordem de ESCRITA vs EXECUÇÃO
+
+**Escrita (sintaxe fixa):**
+```
+SELECT → FROM → JOIN → WHERE → GROUP BY → HAVING → ORDER BY → LIMIT
+```
+
+**Execução (lógica do banco):**
+```
+FROM → JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT
+```
+
+Regras práticas que vêm daí:
+- `WHERE` filtra **antes** de agrupar; `HAVING` filtra o **grupo** (depois).
+- `WHERE` **não** aceita função agregada (`COUNT`, `SUM`...).
+- Alias do `SELECT` **não** existe em `WHERE`/`GROUP BY`, mas **existe** em `ORDER BY`.
+
+```sql
+-- ERRADO no Spark SQL:
+SELECT SALDO_TOTAL AS saldo FROM contas WHERE saldo > 0;
+-- CERTO:
+SELECT SALDO_TOTAL AS saldo FROM cont…… WHERE SALDO_TOTAL > 0 ORDER BY saldo;
+```
+
+---
+
+## 3. INNER JOIN — interseção (∩)
+
+Só traz linhas onde a chave combina **nos dois** lados. O que não tem par, some.
+
+```sql
+SELECT c.NUM_CONTA, cl.PRIMEIRO_NOME
+FROM contas c
+INNER JOIN clientes cl
+    ON cl.COD_CLIENTE = c.COD_CLIENTE;
+```
+`ON` = regra do encontro (a FK em comum). No Banvic: `COD_CLIENTE`, `COD_AGENCIA`, `NUM_CONTA`.
+
+Esquema:
+```
+contas:   [A, B, C, D]
+clientes: [B, C, E]
+INNER → [B, C]
+```
+
+---
+
+## 4. LEFT vs RIGHT JOIN
+
+| Tipo | Traz |
+|------|------|
+| **INNER** | só o que bate nos dois |
+| **LEFT** | **tudo da esquerda** + o que casar da direita (NULL se não achar) |
+| **RIGHT** | tudo da direita + o que casar da esquerda |
+| **FULL** | tudo dos dois (NULL onde não bater) |
+
+**"LEFT" é literal:** é a tabela à esquerda do `JOIN` (a do `FROM`).
+```sql
+FROM clientes cl LEFT JOIN contas c   -- cl nunca some
+```
+`RIGHT JOIN` é redundante (sempre dá pra reescrever como LEFT trocando a ordem). Por isso quase ninguém usa.
+
+Esquema:
+```
+contas:   [A,B,C,D]   clientes: [B,C,E]
+LEFT  (de contas)  → [A,B,C,D]
+RIGHT (de contas)  → [B,C,E]
+```
+
+---
+
+## 5. UNION vs UNION ALL — empilha (vertical)
+
+Diferente do JOIN (horizontal, colunas lado a lado), UNION **empilha linhas**.
+
+| | Efeito | Conjunto |
+|--|--------|----------|
+| **UNION** | empilha e **remove duplicatas** | união ∪ |
+| **UNION ALL** | empilha **tudo** (inclusive repetidos) | concatena listas |
+
+Regras obrigatórias: mesma **quantidade**, **ordem** e **tipos** de colunas.
+
+Exemplo Banvic (clientes + colaboradores têm `PRIMEIRO_NOME, ULTIMO_NOME, EMAIL`):
+```sql
+SELECT PRIMEIRO_NOME, ULTIMO_NOME, EMAIL, 'cliente' AS tipo FROM clientes
+UNION ALL
+SELECT PRIMEIRO_NOME, ULTIMO_NOME, EMAIL, 'colaborador' AS tipo FROM colaboradores;
+```
+
+**UNION (vertical) vs JOIN (horizontal):**
+- JOIN: colunas das tabelas na mesma linha.
+- UNION: linhas das tabelas empilhadas.
+
+---
+
+## Checklist de fixação
+- [ ] Escrever query com alias de tabela + coluna
+- [ ] Escrever CTE
+- [ ] INNER JOIN entre 2 tabelas Banvic
+- [ ] LEFT JOIN mostrando clientes sem conta (NULL)
+- [ ] UNION ALL de clientes + colaboradores

aprendizado/setup_execucao.md

@@ -0,0 +1,87 @@
+# Setup de Execução (Databricks + dbt) — fazer DEPOIS de estudar a teoria
+
+> Este arquivo é um **lembrete de como rodar de fato** o projeto. Não é necessário
+> durante o estudo de SQL via chat. Use quando quiser executar queries/seed/run no banco.
+
+---
+
+## Pré-requisitos
+
+- Conta Databricks (a do trabalho já serve — catálogo `mesh_dev_db`, schema base `dev_carlos_castro_dbt`)
+- `dbt-databricks` instalado (`pip install dbt-databricks`)
+- dbt no PATH: `C:\Users\Jesse\AppData\Roaming\Python\Python314\Scripts`
+
+---
+
+## 1. Criar o `profiles.yml` (FORA do repo)
+
+Local: `C:\Users\Jesse\.dbt\profiles.yml`
+
+```yaml
+default:
+  target: dev
+  outputs:
+    dev:
+      type: databricks
+      catalog: mesh_dev_db
+      schema: dev_carlos_castro_dbt
+      host: <SEU_WORKSPACE>.cloud.databricks.com
+      http_path: /sql/1.0/warehouses/<WAREHOUSE_ID>
+      token: <SEU_TOKEN_PESSOAL>
+      threads: 4
+```
+
+Onde pegar:
+- **host** → URL do workspace (sem `https://`)
+- **http_path** → SQL → Warehouses → seu warehouse → Connection details
+- **token** → Settings (⚙️) → Developer → Access tokens → Generate
+
+⚠️ **NUNCA** commite o `profiles.yml` (tem token = senha). Ele fica fora do repo.
+
+---
+
+## 2. Validar conexão
+
+```bash
+cd <pasta do banvic-dbt>
+dbt debug
+```
+Se der OK, a ponte está feita.
+
+---
+
+## 3. Carregar as tabelas do Banvic (seeds)
+
+As seeds estão desabilitadas por padrão em `dbt_project.yml` (`+enabled: false`).
+Carregar uma por uma:
+```bash
+dbt seed -s clientes
+dbt seed -s contas
+dbt seed -s transacoes
+dbt seed -s agencias
+dbt seed -s localidades
+dbt seed -s colaboradores
+dbt seed -s colaborador_agencia
+dbt seed -s propostas_credito
+```
+(Schemas criados: `mesh_dev_db.erp_banvic` para as seeds.)
+
+---
+
+## 4. Rodar models e testes
+
+```bash
+dbt run --select staging        # camada staging
+dbt run --select +marts.fact_transacoes
+dbt test                         # validação de qualidade
+```
+
+---
+
+## 5. Onde rodar queries ad-hoc (SQL puro do Módulo 2)
+
+No Databricks: **SQL → Query Editor** → aponte pro catálogo `mesh_dev_db` e pro schema
+das tabelas (`erp_banvic` após o seed, ou `dev_carlos_castro_dbt_staging` após o run).
+É lá que você pratica os `SELECT`/`JOIN`/`UNION` do caderno `modulo2_sql.md`.
+
+> Enquanto estuda só a teoria, não precisa de nada disso — o chat já serve.

dbt_project.yml

@@ -39,4 +39,4 @@ seeds:
   my_new_project: # <-- Name of the project. If you renamed your project you have to change this as well
     banvic:
       +schema: erp_banvic
-      +enabled: false
+      +enabled: true

models/intermediate/int_dimensao_agencias.sql

@@ -0,0 +1,24 @@
+with
+agencias as (
+    select *
+    from {{ ref('stg_erp__agencias') }}
+),
+
+localidades as (
+    select *
+    from {{ ref('stg_erp__localidades') }}
+),
+
+agencias_enriquecido as (
+    select
+        agencias.pk_agencia
+        , agencias.nome_agencia
+        , agencias.tipo_agencia
+        , localidades.cidade as cidade_agencia
+        , localidades.uf as uf_agencia
+    from agencias
+    left join localidades on agencias.fk_localidade = localidades.pk_localidade
+)
+
+select *
+from agencias_enriquecido