From 898504c5a9977085040f129c39518c2378b70293 Mon Sep 17 00:00:00 2001 From: ThomasTDS Date: Mon, 19 Oct 2026 14:30:12 -0300 Subject: [PATCH 1/2] Adiciona investigacao 08: duplicidade aproximada no catalogo Novo defeito na massa quebrada: o produto 9, "Consutoria avulsa - hora", e um cadastro duplicado do produto 5 com erro de digitacao no nome, e a venda do pedido 13 foi lancada nele. Relatorio, exploracao.sql e deteccao.sql no formato das anteriores. A deteccao usa similaridade por trigramas (extensao pg_trgm, ativada no schema) com limite de 0,6, escolhido pelos dados: o limite padrao da extensao (0,3) marcaria produtos legitimos como duplicados. O relatorio 07 ganha a linha do produto 9 e registra que a categoria dividida em duas, que ele apontava como risco, aconteceu. READMEs (dois idiomas), diagrama e comentarios atualizados para 8 defeitos; validacao com 21 checks. --- README.en.md | 15 +- README.md | 15 +- .../07-codificacao-quebrada/README.md | 5 +- .../resultado-esperado.json | 3 +- .../08-duplicidade-aproximada/README.md | 211 ++++++++++++++++++ .../08-duplicidade-aproximada/deteccao.sql | 28 +++ .../08-duplicidade-aproximada/exploracao.sql | 72 ++++++ .../resultado-esperado.json | 59 +++++ scripts/validate.js | 6 + sql/01_schema.sql | 6 +- sql/03_seed_quebrado.sql | 16 +- validacoes/README.md | 2 +- 12 files changed, 420 insertions(+), 18 deletions(-) create mode 100644 investigacoes/08-duplicidade-aproximada/README.md create mode 100644 investigacoes/08-duplicidade-aproximada/deteccao.sql create mode 100644 investigacoes/08-duplicidade-aproximada/exploracao.sql create mode 100644 investigacoes/08-duplicidade-aproximada/resultado-esperado.json diff --git a/README.en.md b/README.en.md index d2b1db2..51ad975 100644 --- a/README.en.md +++ b/README.en.md @@ -8,7 +8,7 @@ ## Description -This repository simulates a sales CRM/ERP database with real-world data defects (duplicate customers, orphaned foreign keys, inconsistent statuses, invalid dates, duplicate payments, fake values in required fields and text with broken encoding) and documents the SQL investigations that find each one of them. It uses the same method applied when investigating production bugs: symptom → hypotheses → queries and evidence → root cause → impact → proposed fix. +This repository simulates a sales CRM/ERP database with real-world data defects (duplicate customers, orphaned foreign keys, inconsistent statuses, invalid dates, duplicate payments, fake values in required fields, text with broken encoding and near-duplicates in the catalog) and documents the SQL investigations that find each one of them. It uses the same method applied when investigating production bugs: symptom → hypotheses → queries and evidence → root cause → impact → proposed fix. This is not a SQL syntax exercise. The goal is to show how to use SQL to **find real defects** in a database whose data is already corrupted, the way it would happen while investigating a bug reported in production. @@ -53,7 +53,7 @@ erDiagram produtos { int id PK - varchar nome "text not validated (inv. 07)" + varchar nome "text not validated (inv. 07), no UNIQUE (inv. 08)" numeric preco "CHECK >= 0" varchar categoria "optional, text not validated (inv. 07)" } @@ -84,7 +84,7 @@ erDiagram } ``` -The **inv. 01** to **inv. 07** notes mark the schema characteristic that is the root cause of each [investigated defect](#the-7-investigated-defects). For example, the missing `UNIQUE` on `email` and `documento` is what allows the duplicate customers of investigation 01. +The **inv. 01** to **inv. 08** notes mark the schema characteristic that is the root cause of each [investigated defect](#the-8-investigated-defects). For example, the missing `UNIQUE` on `email` and `documento` is what allows the duplicate customers of investigation 01. --- @@ -105,7 +105,8 @@ sql-defect-investigation/ │ ├── 04-data-invalida/ # same structure │ ├── 05-pagamento-duplicado/ # same structure │ ├── 06-dados-de-mentira/ # same structure -│ └── 07-codificacao-quebrada/ # same structure +│ ├── 07-codificacao-quebrada/ # same structure +│ └── 08-duplicidade-aproximada/ # same structure ├── validacoes/ # value consistency rules (total, payment, catalog) ├── sql/ │ ├── 01_schema.sql # DDL: tables, FKs, constraints @@ -176,7 +177,7 @@ Dependencies are kept up to date by **Dependabot** ([`.github/dependabot.yml`](. --- -## The 7 investigated defects +## The 8 investigated defects | # | Defect | Simulated real-world scenario | Investigation | |---|--------|-------------------------------|---------------| @@ -187,6 +188,7 @@ Dependencies are kept up to date by **Dependabot** ([`.github/dependabot.yml`](. | 5 | Duplicate payment | The gateway resent the payment confirmation (webhook) and the application recorded both, with no idempotency key | [Report](investigacoes/05-pagamento-duplicado/README.md) | | 6 | Fake values in required fields | In phone sales sign-ups, email and CPF (Brazilian taxpayer ID) are required, and the agent typed filler values when the customer did not provide them | [Report](investigacoes/06-dados-de-mentira/README.md) | | 7 | Text with broken encoding (mojibake) | The catalog sync with the ERP read a UTF-8 file as Windows-1252 | [Report](investigacoes/07-codificacao-quebrada/README.md) | +| 8 | Near-duplicate in the catalog | The sales screen search is exact, did not find the product, and the sales rep created another one with a typo in the name | [Report](investigacoes/08-duplicidade-aproximada/README.md) | The reports are in Portuguese. @@ -201,6 +203,7 @@ The reports are in Portuguese. | 5 | Order 2 has two identical approved payments, 4 seconds apart: the system records R$ 199.80 received for a single R$ 99.90 transaction at the gateway | The `pagamentos` table does not store the gateway transaction id, so a resent webhook becomes a new payment | | 6 | Three sign-ups rejected by the credit check: two with the email `naotem@naotem.com` ("don't have one") and fake CPFs (which **pass** the check-digit test), and one with two CPF digits swapped | `NOT NULL` only ensures the field is not empty: nothing validates its content, and the form offers no "not provided" option | | 7 | Products named like "Módulo de Relatórios" in the emails of 5 orders, while "Plano Básico Mensal" is still correct: the defect is in the data, not in how it is displayed | The ERP sync reads the UTF-8 file as Windows-1252; the reverse operation restores the original text exactly, which proves the diagnosis | +| 8 | "Consultoria Avulsa (hora)" and "Consutoria avulsa - hora" are the same service, with its sales split between the two. No exact comparison links them, but text similarity (`pg_trgm`) gives 0.808, and the extension's default threshold (0.3) would flag legitimate plans as duplicates | `produtos.nome` has no uniqueness constraint, and the exact search on the sales screen pushes the rep into creating the product again | Each report ends with a proposed fix, tested on a disposable copy of the database but **not applied**: as in a real investigation, QA delivers evidence and a recommendation, and the decision to change the data belongs to the responsible team. @@ -218,7 +221,7 @@ Change the folder to run the other investigations. Each defect is implemented and commented in `sql/03_seed_quebrado.sql`. Each investigation lives in `investigacoes/`, with a full report and the detection query (`deteccao.sql`), which the CI runs against both datasets. That way, what is documented is exactly what is tested. -Besides the 7 defects, the validation also checks value consistency rules (order total = sum of its items, approved payments = order total, and item price equal to the catalog price in the control dataset). The rules, and the reason for each one, are in [`validacoes/`](validacoes/README.md) (in Portuguese). +Besides the 8 defects, the validation also checks value consistency rules (order total = sum of its items, approved payments = order total, and item price equal to the catalog price in the control dataset). The rules, and the reason for each one, are in [`validacoes/`](validacoes/README.md) (in Portuguese). ### When the data changes diff --git a/README.md b/README.md index 65b82b0..5026e67 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ ## Descrição -Este repositório simula um banco de dados de CRM/ERP de vendas com defeitos de dados reais — clientes duplicados, foreign keys órfãs, status inconsistentes, datas inválidas, pagamentos em duplicidade, valores de mentira em campos obrigatórios e texto com codificação quebrada — e documenta as investigações SQL que encontram cada um deles, com a mesma metodologia usada em investigação de bugs de produção: sintoma → hipóteses → queries e evidências → causa raiz → impacto → correção proposta. +Este repositório simula um banco de dados de CRM/ERP de vendas com defeitos de dados reais — clientes duplicados, foreign keys órfãs, status inconsistentes, datas inválidas, pagamentos em duplicidade, valores de mentira em campos obrigatórios, texto com codificação quebrada e duplicidade aproximada no catálogo — e documenta as investigações SQL que encontram cada um deles, com a mesma metodologia usada em investigação de bugs de produção: sintoma → hipóteses → queries e evidências → causa raiz → impacto → correção proposta. Não é um exercício de sintaxe SQL: o objetivo é demonstrar a habilidade de usar SQL para **encontrar defeito real** num banco com dados já corrompidos, do jeito que aconteceria investigando um bug relatado em produção. @@ -49,7 +49,7 @@ erDiagram produtos { int id PK - varchar nome "texto sem validação (inv. 07)" + varchar nome "texto sem validação (inv. 07), sem UNIQUE (inv. 08)" numeric preco "CHECK >= 0" varchar categoria "opcional, texto sem validação (inv. 07)" } @@ -80,7 +80,7 @@ erDiagram } ``` -As anotações **inv. 01** a **inv. 07** marcam a característica do schema que é a causa raiz de cada [defeito investigado](#os-7-defeitos-investigados). Por exemplo, a falta de `UNIQUE` em `email` e `documento` é o que permite os clientes duplicados da investigação 01. +As anotações **inv. 01** a **inv. 08** marcam a característica do schema que é a causa raiz de cada [defeito investigado](#os-8-defeitos-investigados). Por exemplo, a falta de `UNIQUE` em `email` e `documento` é o que permite os clientes duplicados da investigação 01. --- @@ -101,7 +101,8 @@ sql-defect-investigation/ │ ├── 04-data-invalida/ # mesma estrutura │ ├── 05-pagamento-duplicado/ # mesma estrutura │ ├── 06-dados-de-mentira/ # mesma estrutura -│ └── 07-codificacao-quebrada/ # mesma estrutura +│ ├── 07-codificacao-quebrada/ # mesma estrutura +│ └── 08-duplicidade-aproximada/ # mesma estrutura ├── validacoes/ # regras de consistência de valores (total, pagamento, catálogo) ├── sql/ │ ├── 01_schema.sql # DDL: tabelas, FKs, constraints @@ -172,7 +173,7 @@ As dependências são mantidas pelo **Dependabot** ([`.github/dependabot.yml`](. --- -## Os 7 defeitos investigados +## Os 8 defeitos investigados | # | Defeito | Cenário real simulado | Investigação | |---|---------|------------------------|--------------| @@ -183,6 +184,7 @@ As dependências são mantidas pelo **Dependabot** ([`.github/dependabot.yml`](. | 5 | Pagamento em duplicidade | O gateway reenviou a confirmação do pagamento (webhook) e a aplicação registrou as duas, sem chave de idempotência | [Relatório](investigacoes/05-pagamento-duplicado/README.md) | | 6 | Valores de mentira em campos obrigatórios | No cadastro por televendas, e-mail e CPF são obrigatórios, e o atendente digitou valores de preenchimento quando o cliente não informou | [Relatório](investigacoes/06-dados-de-mentira/README.md) | | 7 | Texto com codificação quebrada | A sincronização do catálogo com o ERP leu um arquivo UTF-8 como Windows-1252 | [Relatório](investigacoes/07-codificacao-quebrada/README.md) | +| 8 | Duplicidade aproximada no catálogo | A busca da tela de venda é exata, não achou o produto, e o vendedor cadastrou outro com o nome digitado errado | [Relatório](investigacoes/08-duplicidade-aproximada/README.md) | ### Principais achados @@ -195,6 +197,7 @@ As dependências são mantidas pelo **Dependabot** ([`.github/dependabot.yml`](. | 5 | O pedido 2 tem dois pagamentos aprovados idênticos, com 4 segundos de diferença: o sistema registra R$ 199,80 recebidos para uma única transação de R$ 99,90 no gateway | A tabela `pagamentos` não guarda o id da transação do gateway, então um webhook reenviado vira um pagamento novo | | 6 | Três cadastros barrados na análise de crédito: dois com o e-mail `naotem@naotem.com` e CPFs de mentira (que **passam** no dígito verificador) e um com dois dígitos do CPF trocados | `NOT NULL` só garante que o campo não está vazio: nada valida o conteúdo, e o formulário não oferece "não informado" | | 7 | Produtos com nomes como "Módulo de Relatórios" em e-mails de 5 pedidos, enquanto o "Plano Básico Mensal" continua certo: o defeito está no dado, não na exibição | A sincronização com o ERP lê o arquivo UTF-8 como Windows-1252, e a operação inversa devolve o texto original exatamente, o que prova o diagnóstico | +| 8 | "Consultoria Avulsa (hora)" e "Consutoria avulsa - hora" são o mesmo serviço, com as vendas divididas entre os dois. Nenhuma comparação exata os liga, mas a similaridade de texto (`pg_trgm`) dá 0.808, e o limite padrão da extensão (0.3) marcaria planos legítimos como duplicados | `produtos.nome` não tem nenhuma restrição de unicidade, e a busca exata da tela de venda empurra o vendedor a cadastrar de novo | Cada relatório termina com uma correção proposta, testada numa cópia descartável do banco, mas **não executada**: como numa investigação real, o QA entrega evidência e recomendação, e a decisão de mexer nos dados é do time responsável. @@ -212,7 +215,7 @@ Basta trocar a pasta para rodar as outras investigações. Cada defeito está implementado e comentado em `sql/03_seed_quebrado.sql`. Cada investigação fica em `investigacoes/`, com um relatório completo e a query de detecção (`deteccao.sql`), que a CI executa contra as duas massas de dados. Assim, o que está documentado é exatamente o que é testado. -Além dos 7 defeitos, a validação confere regras de consistência de valores (total do pedido = soma dos itens, pagamentos aprovados = total do pedido, e o preço do item igual ao do catálogo na massa de controle). As regras e o motivo de cada uma estão em [`validacoes/`](validacoes/README.md). +Além dos 8 defeitos, a validação confere regras de consistência de valores (total do pedido = soma dos itens, pagamentos aprovados = total do pedido, e o preço do item igual ao do catálogo na massa de controle). As regras e o motivo de cada uma estão em [`validacoes/`](validacoes/README.md). ### Quando a massa de dados muda diff --git a/investigacoes/07-codificacao-quebrada/README.md b/investigacoes/07-codificacao-quebrada/README.md index 9f8c826..cedd56d 100644 --- a/investigacoes/07-codificacao-quebrada/README.md +++ b/investigacoes/07-codificacao-quebrada/README.md @@ -48,8 +48,9 @@ SELECT id, nome, categoria FROM produtos ORDER BY id; | 6 | **Módulo de Relatórios** | Add-on | | 7 | **Módulo de Integrações** | Add-on | | 8 | **Suporte Prioritário** | Add-on | +| 9 | Consutoria avulsa - hora | Serviço | -**Achado:** **H1 descartada.** O nome já está gravado errado no banco, e o e-mail só mostra o que recebeu. O detalhe mais importante é o produto `1`: **"Plano Básico Mensal" está correto**, com o "á" no lugar. Uma parte dos acentos está certa e outra está quebrada. +**Achado:** **H1 descartada.** O nome já está gravado errado no banco, e o e-mail só mostra o que recebeu. O detalhe mais importante é o produto `1`: **"Plano Básico Mensal" está correto**, com o "á" no lugar. Uma parte dos acentos está certa e outra está quebrada. O produto `9` também está correto, porque foi cadastrado à mão, fora da sincronização. Ele é um cadastro duplicado do produto `5`, assunto da [investigação 08](../08-duplicidade-aproximada/README.md). ### Passo 2: os bytes de um nome certo e de um quebrado @@ -134,7 +135,7 @@ GROUP BY pr.id, pr.nome; - **Cliente:** nomes de produto quebrados em e-mails e documentos de 5 pedidos, o que passa uma imagem de sistema malfeito. - **Busca:** quem procurar "Módulo" no catálogo não encontra os produtos `6` e `7`. -- **Relatórios:** a categoria "Serviço" é, para o banco, um texto **diferente** de "Serviço". Hoje os dois produtos da categoria estão quebrados, então ela só aparece com o nome errado. Mas basta a próxima sincronização regravar só um deles, ou um produto novo entrar certo, para a categoria se dividir em duas linhas em qualquer relatório agrupado por categoria. +- **Relatórios:** a categoria "Serviço" é, para o banco, um texto **diferente** de "Serviço". Os dois produtos que vieram da sincronização estão em "Serviço", e o produto `9`, cadastrado à mão, está em "Serviço" correto. **A categoria já está dividida em duas**: qualquer relatório agrupado por categoria mostra "Serviço" e "Serviço" como se fossem categorias diferentes. - **Reincidência:** como a causa está no importador, **a próxima sincronização quebra de novo** qualquer produto acentuado que for alterado no ERP. ## 6. Correção proposta diff --git a/investigacoes/07-codificacao-quebrada/resultado-esperado.json b/investigacoes/07-codificacao-quebrada/resultado-esperado.json index 3c5fd40..ceb3046 100644 --- a/investigacoes/07-codificacao-quebrada/resultado-esperado.json +++ b/investigacoes/07-codificacao-quebrada/resultado-esperado.json @@ -10,7 +10,8 @@ ["5","Consultoria Avulsa (hora)","Serviço"], ["6","Módulo de Relatórios","Add-on"], ["7","Módulo de Integrações","Add-on"], - ["8","Suporte Prioritário","Add-on"] + ["8","Suporte Prioritário","Add-on"], + ["9","Consutoria avulsa - hora","Serviço"] ] }, { diff --git a/investigacoes/08-duplicidade-aproximada/README.md b/investigacoes/08-duplicidade-aproximada/README.md new file mode 100644 index 0000000..a035ec7 --- /dev/null +++ b/investigacoes/08-duplicidade-aproximada/README.md @@ -0,0 +1,211 @@ +# Investigação 08 — Duplicidade aproximada no catálogo + +| | | +|---|---| +| **Defeito** | O mesmo serviço cadastrado duas vezes no catálogo, com nomes parecidos mas não iguais | +| **Registros afetados** | Produtos `5` ("Consultoria Avulsa (hora)") e `9` ("Consutoria avulsa - hora"), e o pedido `13`, lançado no cadastro duplicado | +| **Causa raiz** | A busca de produtos da tela de venda é por texto exato e não achou o produto existente. O vendedor cadastrou um novo, e nada no banco impede dois produtos com o mesmo nome (nem com nomes parecidos) | +| **Severidade** | Média: as vendas do serviço ficam divididas entre dois cadastros, e relatórios por produto e por categoria saem errados | +| **Status** | Diagnóstico concluído, com correção proposta e **não executada** | + +Arquivos desta investigação: + +- [`exploracao.sql`](exploracao.sql): as queries na ordem em que foram usadas, numeradas conforme os passos abaixo. +- [`deteccao.sql`](deteccao.sql): a query final de detecção, que usa similaridade de texto (`pg_trgm`) para achar nomes de produtos parecidos. É a mesma query que a CI executa. + +--- + +## 1. Sintoma relatado + +> Chamado do comercial: no relatório de vendas por produto aparece um item **"Consutoria avulsa - hora"**, que ninguém lembra de ter criado, e as vendas de consultoria parecem mais baixas do que o time esperava. + +## 2. Hipóteses iniciais + +| # | Hipótese | Como confirmar ou descartar | +|---|---|---| +| H1 | É um produto novo e legítimo, um serviço diferente | Comparar preço, categoria e nome com o catálogo existente | +| H2 | É o mesmo serviço cadastrado de novo, com outro nome | Procurar no catálogo nomes parecidos, e não só iguais | +| H3 | Há outros produtos duplicados | Medir a similaridade entre todos os pares de produtos | + +## 3. Investigação + +### Passo 1: o relatório de vendas por produto + +```sql +SELECT pr.id AS produto_id, pr.nome AS produto, COUNT(i.id) AS qtd_itens, + COALESCE(SUM(i.quantidade * i.preco_unitario), 0) AS receita +FROM produtos pr +LEFT JOIN itens_pedido i ON i.produto_id = pr.id +GROUP BY pr.id, pr.nome +ORDER BY receita DESC, pr.id; +``` + +| produto_id | produto | qtd_itens | receita | +|---|---|---|---| +| 4 | Pacote de Onboarding | 1 | 500.00 | +| 3 | Plano Enterprise Mensal | 2 | 499.80 | +| **5** | **Consultoria Avulsa (hora)** | 2 | **300.00** | +| 6 | Módulo de Relatórios | 3 | 239.70 | +| **9** | **Consutoria avulsa - hora** | 1 | **150.00** | +| 7 | Módulo de Integrações | 1 | 119.90 | +| 2 | Plano Profissional Mensal | 1 | 99.90 | +| 1 | Plano Básico Mensal | 2 | 99.80 | +| 8 | Suporte Prioritário | 1 | 59.90 | + +**Achado:** o produto `9` tem o **mesmo preço** do `5` (R$ 150,00 por hora) e um nome quase igual, com um erro de digitação ("Consutoria"). Tudo indica que é o mesmo serviço, o que **descarta H1**. A confirmação final é do time comercial, mas um serviço diferente teria outro nome, e não o mesmo nome escrito errado. Os nomes quebrados ("Módulo"...) são outro defeito, da [investigação 07](../07-codificacao-quebrada/README.md). + +### Passo 2: por que a comparação exata não acha + +A primeira ideia seria comparar os nomes de forma "tolerante", ignorando maiúsculas e pontuação: + +```sql +SELECT id, nome, + lower(nome) = lower('Consultoria Avulsa (hora)') AS igual_ignorando_maiusculas, + trim(regexp_replace(lower(nome), '[[:punct:][:space:]]+', ' ', 'g')) + = trim(regexp_replace(lower('Consultoria Avulsa (hora)'), '[[:punct:][:space:]]+', ' ', 'g')) AS igual_sem_pontuacao +FROM produtos +WHERE id IN (5, 9); +``` + +| id | nome | igual_ignorando_maiusculas | igual_sem_pontuacao | +|---|---|---|---| +| 5 | Consultoria Avulsa (hora) | true | true | +| 9 | Consutoria avulsa - hora | false | false | + +**Achado:** nenhuma comparação exata reconhece o produto `9`, nem a mais tolerante. Basta uma letra faltando ("Consutoria") para a igualdade falhar. É o mesmo motivo pelo qual a busca da tela de venda, que é por texto exato, não achou o produto `5`, e o vendedor acabou cadastrando outro. + +### Passo 3: similaridade entre todos os pares + +Para achar nomes **parecidos**, a extensão `pg_trgm` do PostgreSQL quebra cada nome em sequências de 3 letras (trigramas) e mede a fração em comum: 0 é nada em comum, 1 é igual. Ela já ignora maiúsculas e pontuação, e um erro de digitação só afeta alguns trigramas. Para todos os pares de produtos: + +```sql +SELECT a.id AS produto_a, b.id AS produto_b, a.nome AS nome_a, b.nome AS nome_b, + round(similarity(a.nome, b.nome)::numeric, 3) AS similaridade +FROM produtos a +JOIN produtos b ON a.id < b.id +ORDER BY similarity(a.nome, b.nome) DESC +LIMIT 6; +``` + +| produto_a | produto_b | nome_a | nome_b | similaridade | +|---|---|---|---|---| +| **5** | **9** | **Consultoria Avulsa (hora)** | **Consutoria avulsa - hora** | **0.808** | +| 1 | 2 | Plano Básico Mensal | Plano Profissional Mensal | 0.419 | +| 1 | 3 | Plano Básico Mensal | Plano Enterprise Mensal | 0.419 | +| 2 | 3 | Plano Profissional Mensal | Plano Enterprise Mensal | 0.371 | +| 6 | 7 | Módulo de Relatórios | Módulo de Integrações | 0.297 | +| 4 | 6 | Pacote de Onboarding | Módulo de Relatórios | 0.073 | + +**Achados:** + +- **H2 confirmada:** o par `5` e `9` tem similaridade **0.808**, muito acima de todos os outros. +- **A escolha do limite importa.** Os três planos ("Plano Básico Mensal", "Plano Profissional Mensal", "Plano Enterprise Mensal") são produtos **legítimos e diferentes**, mas compartilham "Plano" e "Mensal" e chegam a **0.419**. O limite padrão da `pg_trgm` (o operador `%`) é **0.3**, e com ele os três pares de planos seriam marcados como duplicados: três falsos positivos para um caso real. +- **O limite foi definido pelos dados:** 0.6 fica no meio do intervalo entre o maior par legítimo (0.419) e o duplicado (0.808). Num catálogo maior, esse intervalo pode ser menor, e o resultado da detecção deve ser tratado como **lista de suspeitos para revisão**, e não como certeza. + +### Passo 4: a detecção final — é isolado? + +A query de [`deteccao.sql`](deteccao.sql) lista os pares com similaridade de pelo menos 0.6. Ela mostra também se o preço é o mesmo, um sinal a mais para quem revisar. + +| produto_original | produto_suspeito | nome_original | nome_suspeito | similaridade | mesmo_preco | +|---|---|---|---|---|---| +| 5 | 9 | Consultoria Avulsa (hora) | Consutoria avulsa - hora | 0.808 | true | + +**Achado:** **H3 descartada.** É o único par suspeito do catálogo. + +### Passo 5: impacto — as vendas divididas + +```sql +SELECT pr.id AS produto_id, pr.nome AS produto, pr.categoria, + array_to_string(array_agg(i.pedido_id ORDER BY i.pedido_id), ', ') AS pedidos, + SUM(i.quantidade * i.preco_unitario) AS receita +FROM produtos pr +JOIN itens_pedido i ON i.produto_id = pr.id +WHERE pr.id IN (5, 9) +GROUP BY pr.id, pr.nome, pr.categoria; +``` + +| produto_id | produto | categoria | pedidos | receita | +|---|---|---|---|---| +| 5 | Consultoria Avulsa (hora) | Serviço | 5, 9 | 300.00 | +| 9 | Consutoria avulsa - hora | Serviço | 13 | 150.00 | + +**Achados:** + +- A consultoria vendeu **R$ 450,00** em 3 pedidos, mas o relatório mostra R$ 300,00 num produto e R$ 150,00 em outro. +- **Dois defeitos se somam na categoria:** o produto `5` está em "Serviço", com o texto quebrado da [investigação 07](../07-codificacao-quebrada/README.md), e o `9`, cadastrado à mão, está em "Serviço" correto. A categoria aparece dividida em duas, exatamente o risco que a investigação 07 apontava. + +### Passo 6: causa raiz — o que o banco garante sobre o nome + +```sql +SELECT indexname, indexdef FROM pg_indexes WHERE tablename = 'produtos'; +``` + +| indexname | indexdef | +|---|---| +| produtos_pkey | CREATE UNIQUE INDEX produtos_pkey ON public.produtos USING btree (id) | + +**Achado:** a única regra de unicidade é o `id`. Nada impede dois produtos com o **mesmo** nome, e muito menos com nomes **parecidos**. + +## 4. Causa raiz + +1. **Aplicação (causa raiz):** a busca de produtos da tela de venda é por texto exato. Quando o vendedor não achou a consultoria (por digitar diferente, ou por buscar "consultoria hora"), a única saída que a tela oferecia era cadastrar um produto novo. +2. **Banco (por que passou):** `produtos.nome` não tem nenhuma restrição de unicidade, e nenhum processo compara um nome novo com os existentes antes de gravar. + +## 5. Impacto + +- **Relatórios:** vendas de um mesmo serviço divididas entre dois produtos, o que distorce ranking, metas e comissões por produto. +- **Categoria dividida:** somado ao defeito da investigação 07, o mesmo serviço aparece em duas categorias, "Serviço" e "Serviço". +- **Manutenção:** um reajuste de preço feito em um dos cadastros não vale para o outro, e o catálogo deriva com o tempo. + +## 6. Correção proposta + +> **Não executada.** A correção foi testada numa cópia descartável do banco. Depois dela, o produto `5` tem os 3 pedidos (5, 9 e 13) e R$ 450,00, e um novo cadastro "consultoria avulsa - HORA" é bloqueado pelo índice único. O teste também mostrou o **limite** do índice: "Consutoria avulsa - hora", com erro de digitação, passa por ele, e por isso a correção tem duas camadas. + +### 6.1 Unificar os cadastros + +```sql +BEGIN; + +UPDATE itens_pedido SET produto_id = 5 WHERE produto_id = 9; +DELETE FROM produtos WHERE id = 9; + +COMMIT; +``` + +Antes de rodar, confirmar com o time comercial que os dois produtos são o mesmo serviço (passo 1). O registro mantido é o original (`5`). Assim como nas investigações 01 e 05, vale guardar uma cópia do registro removido. + +### 6.2 Impedir nomes iguais (com variações de escrita) + +```sql +CREATE UNIQUE INDEX produtos_nome_unico + ON produtos (trim(regexp_replace(lower(nome), '[[:punct:][:space:]]+', ' ', 'g'))); +``` + +O índice é sobre o nome **normalizado** (minúsculas, sem pontuação e com os espaços padronizados). Ele barra "consultoria avulsa - HORA", "Consultoria Avulsa (hora)" e "consultoria avulsa hora" como se fossem o mesmo nome. Os acentos são preservados. + +### 6.3 Sugerir nomes parecidos na tela de cadastro + +O índice da 6.2 **não** pega erro de digitação. Para isso, a tela de cadastro deve, antes de salvar, procurar produtos parecidos e perguntar "você quis dizer...?": + +```sql +SELECT id, nome, round(similarity(nome, $1)::numeric, 3) AS similaridade +FROM produtos +WHERE similarity(nome, $1) >= 0.6 +ORDER BY similaridade DESC; +``` + +Testado com "Consutoria avulsa - hora": a sugestão devolve "Consultoria Avulsa (hora)" com 0.808. A decisão final continua com quem cadastra, porque nomes parecidos podem ser produtos diferentes (como os planos do passo 3). Num catálogo grande, um índice `GIN` com `gin_trgm_ops` deixa essa busca rápida. + +### 6.4 Busca tolerante na tela de venda + +A causa raiz é a busca exata. Trocá-la por uma busca por similaridade, a mesma técnica, faz o vendedor encontrar o produto existente e elimina o motivo para cadastrar outro. + +- **Monitoramento:** rodar o [`deteccao.sql`](deteccao.sql) periodicamente e revisar os pares suspeitos. O limite de 0.6 deve ser revisto se o catálogo crescer. + +## 7. Como reproduzir + +Com o banco no ar (`docker compose up -d --wait`, ver o [README principal](../../README.md)): + +```bash +docker compose exec -T postgres psql -U postgres -d defect_investigation < investigacoes/08-duplicidade-aproximada/exploracao.sql +``` diff --git a/investigacoes/08-duplicidade-aproximada/deteccao.sql b/investigacoes/08-duplicidade-aproximada/deteccao.sql new file mode 100644 index 0000000..2ba65ad --- /dev/null +++ b/investigacoes/08-duplicidade-aproximada/deteccao.sql @@ -0,0 +1,28 @@ +-- Detecção: produtos com nomes muito parecidos, provável cadastro +-- duplicado do mesmo item. +-- +-- Usa a similaridade por trigramas da extensão pg_trgm: o nome é quebrado +-- em sequências de 3 letras, e a similaridade é a fração de sequências em +-- comum (0 = nada em comum, 1 = iguais). Ela já ignora maiúsculas e +-- pontuação, e tolera erros de digitação. +-- +-- O limite de 0,6 foi escolhido a partir dos dados (ver o relatório): o +-- limite padrão da extensão (0,3) marcaria como duplicados produtos +-- legítimos e diferentes, como "Plano Básico Mensal" e "Plano +-- Profissional Mensal" (0,419). +-- +-- Cada linha é um par de produtos suspeito. Resultado esperado: zero +-- linhas. + +SELECT + a.id AS produto_original, + b.id AS produto_suspeito, + a.nome AS nome_original, + b.nome AS nome_suspeito, + round(similarity(a.nome, b.nome)::numeric, 3) AS similaridade, + a.preco = b.preco AS mesmo_preco +FROM produtos a +JOIN produtos b + ON a.id < b.id + AND similarity(a.nome, b.nome) >= 0.6 +ORDER BY similaridade DESC, a.id, b.id; diff --git a/investigacoes/08-duplicidade-aproximada/exploracao.sql b/investigacoes/08-duplicidade-aproximada/exploracao.sql new file mode 100644 index 0000000..036a53f --- /dev/null +++ b/investigacoes/08-duplicidade-aproximada/exploracao.sql @@ -0,0 +1,72 @@ +-- Investigação 08 — Duplicidade aproximada no catálogo +-- Queries na ordem em que foram usadas na investigação. A numeração bate +-- com os passos do README.md desta pasta. + +-- Passo 1: o relatório de vendas por produto, como o time comercial vê. +SELECT + pr.id AS produto_id, + pr.nome AS produto, + COUNT(i.id) AS qtd_itens, + COALESCE(SUM(i.quantidade * i.preco_unitario), 0) AS receita +FROM produtos pr +LEFT JOIN itens_pedido i ON i.produto_id = pr.id +GROUP BY pr.id, pr.nome +ORDER BY receita DESC, pr.id; + +-- Passo 2: a busca exata não acha o produto suspeito — nem ignorando +-- maiúsculas e pontuação. +SELECT + id, + nome, + lower(nome) = lower('Consultoria Avulsa (hora)') AS igual_ignorando_maiusculas, + trim(regexp_replace(lower(nome), '[[:punct:][:space:]]+', ' ', 'g')) + = trim(regexp_replace(lower('Consultoria Avulsa (hora)'), '[[:punct:][:space:]]+', ' ', 'g')) AS igual_sem_pontuacao +FROM produtos +WHERE id IN (5, 9) +ORDER BY id; + +-- Passo 3: similaridade entre todos os pares de produtos, da maior para a +-- menor (as 6 maiores). +SELECT + a.id AS produto_a, + b.id AS produto_b, + a.nome AS nome_a, + b.nome AS nome_b, + round(similarity(a.nome, b.nome)::numeric, 3) AS similaridade +FROM produtos a +JOIN produtos b ON a.id < b.id +ORDER BY similarity(a.nome, b.nome) DESC, a.id, b.id +LIMIT 6; + +-- Passo 4: detecção final (mesma query de deteccao.sql). +SELECT + a.id AS produto_original, + b.id AS produto_suspeito, + a.nome AS nome_original, + b.nome AS nome_suspeito, + round(similarity(a.nome, b.nome)::numeric, 3) AS similaridade, + a.preco = b.preco AS mesmo_preco +FROM produtos a +JOIN produtos b + ON a.id < b.id + AND similarity(a.nome, b.nome) >= 0.6 +ORDER BY similaridade DESC, a.id, b.id; + +-- Passo 5: impacto — as vendas de consultoria somando os dois cadastros. +SELECT + pr.id AS produto_id, + pr.nome AS produto, + pr.categoria, + array_to_string(array_agg(i.pedido_id ORDER BY i.pedido_id), ', ') AS pedidos, + SUM(i.quantidade * i.preco_unitario) AS receita +FROM produtos pr +JOIN itens_pedido i ON i.produto_id = pr.id +WHERE pr.id IN (5, 9) +GROUP BY pr.id, pr.nome, pr.categoria +ORDER BY pr.id; + +-- Passo 6: causa raiz — o que o banco garante sobre o nome do produto? +SELECT indexname, indexdef +FROM pg_indexes +WHERE tablename = 'produtos' +ORDER BY indexname; diff --git a/investigacoes/08-duplicidade-aproximada/resultado-esperado.json b/investigacoes/08-duplicidade-aproximada/resultado-esperado.json new file mode 100644 index 0000000..7940f23 --- /dev/null +++ b/investigacoes/08-duplicidade-aproximada/resultado-esperado.json @@ -0,0 +1,59 @@ +[ + { + "consulta": 1, + "colunas": ["produto_id","produto","qtd_itens","receita"], + "linhas": [ + ["4","Pacote de Onboarding","1","500.00"], + ["3","Plano Enterprise Mensal","2","499.80"], + ["5","Consultoria Avulsa (hora)","2","300.00"], + ["6","Módulo de Relatórios","3","239.70"], + ["9","Consutoria avulsa - hora","1","150.00"], + ["7","Módulo de Integrações","1","119.90"], + ["2","Plano Profissional Mensal","1","99.90"], + ["1","Plano Básico Mensal","2","99.80"], + ["8","Suporte Prioritário","1","59.90"] + ] + }, + { + "consulta": 2, + "colunas": ["id","nome","igual_ignorando_maiusculas","igual_sem_pontuacao"], + "linhas": [ + ["5","Consultoria Avulsa (hora)","t","t"], + ["9","Consutoria avulsa - hora","f","f"] + ] + }, + { + "consulta": 3, + "colunas": ["produto_a","produto_b","nome_a","nome_b","similaridade"], + "linhas": [ + ["5","9","Consultoria Avulsa (hora)","Consutoria avulsa - hora","0.808"], + ["1","2","Plano Básico Mensal","Plano Profissional Mensal","0.419"], + ["1","3","Plano Básico Mensal","Plano Enterprise Mensal","0.419"], + ["2","3","Plano Profissional Mensal","Plano Enterprise Mensal","0.371"], + ["6","7","Módulo de Relatórios","Módulo de Integrações","0.297"], + ["4","6","Pacote de Onboarding","Módulo de Relatórios","0.073"] + ] + }, + { + "consulta": 4, + "colunas": ["produto_original","produto_suspeito","nome_original","nome_suspeito","similaridade","mesmo_preco"], + "linhas": [ + ["5","9","Consultoria Avulsa (hora)","Consutoria avulsa - hora","0.808","t"] + ] + }, + { + "consulta": 5, + "colunas": ["produto_id","produto","categoria","pedidos","receita"], + "linhas": [ + ["5","Consultoria Avulsa (hora)","Serviço","5, 9","300.00"], + ["9","Consutoria avulsa - hora","Serviço","13","150.00"] + ] + }, + { + "consulta": 6, + "colunas": ["indexname","indexdef"], + "linhas": [ + ["produtos_pkey","CREATE UNIQUE INDEX produtos_pkey ON public.produtos USING btree (id)"] + ] + } +] diff --git a/scripts/validate.js b/scripts/validate.js index 1e08bf6..374202a 100644 --- a/scripts/validate.js +++ b/scripts/validate.js @@ -78,6 +78,12 @@ const CHECKS = [ esperadoValido: 0, esperadoQuebrado: 5, }, + { + label: 'produtos com nome muito parecido (provável duplicidade)', + sql: readDeteccao('08-duplicidade-aproximada'), + esperadoValido: 0, + esperadoQuebrado: 1, + }, { // 1 na massa quebrada: o pedido 10 tem valor_total e nenhum item. label: 'pedidos com total diferente da soma dos itens', diff --git a/sql/01_schema.sql b/sql/01_schema.sql index b170edb..c955a4e 100644 --- a/sql/01_schema.sql +++ b/sql/01_schema.sql @@ -3,7 +3,11 @@ -- bastante pra sustentar os tipos de defeito investigados neste projeto -- (duplicidade, FK órfã, status inconsistente, data inválida, pagamento em -- duplicidade, valores de mentira em campos obrigatórios, texto com --- codificação quebrada). +-- codificação quebrada, duplicidade aproximada). + +-- Similaridade de texto por trigramas, usada para achar nomes parecidos +-- (investigação 08). Vem com o PostgreSQL (módulo contrib). +CREATE EXTENSION IF NOT EXISTS pg_trgm; CREATE TABLE clientes ( id SERIAL PRIMARY KEY, diff --git a/sql/03_seed_quebrado.sql b/sql/03_seed_quebrado.sql index 399a68a..6a18772 100644 --- a/sql/03_seed_quebrado.sql +++ b/sql/03_seed_quebrado.sql @@ -1,4 +1,4 @@ --- Introduz, de propósito, os 7 tipos de defeito investigados neste projeto. +-- Introduz, de propósito, os 8 tipos de defeito investigados neste projeto. -- Cada bloco está comentado com o cenário real que ele simula. Execute -- depois de 01_schema.sql + 02_seed_valido.sql. @@ -121,3 +121,17 @@ UPDATE produtos SET categoria = convert_from(convert_to(categoria, 'UTF8'), 'WIN1252') WHERE id IN (4, 5); -- Categoria "Serviço" do Pacote de Onboarding e da Consultoria Avulsa. + +-- ===================================================================== +-- DEFEITO 8: Duplicidade aproximada no catálogo +-- Cenário real: um vendedor precisava lançar uma consultoria e não achou +-- o produto na busca (que é por texto exato). Cadastrou um novo, com o +-- nome digitado à mão e com erro de digitação, e lançou a venda nele. +-- Nada impede: produtos.nome não tem nenhuma restrição de unicidade. +-- ===================================================================== +INSERT INTO produtos (nome, preco, categoria) +VALUES ('Consutoria avulsa - hora', 150.00, 'Serviço'); +-- Mesmo serviço do produto 5 ("Consultoria Avulsa (hora)"), mesmo preço. + +UPDATE itens_pedido SET produto_id = currval('produtos_id_seq') WHERE pedido_id = 13; +-- A consultoria do pedido 13 foi lançada no produto duplicado. diff --git a/validacoes/README.md b/validacoes/README.md index 481c09e..0b1fbc6 100644 --- a/validacoes/README.md +++ b/validacoes/README.md @@ -1,6 +1,6 @@ # Validações de consistência de valores -Regras sobre os **valores** de pedidos, itens e pagamentos que não fazem parte dos 7 defeitos investigados, mas que o `npm run validate` confere a cada execução (e a CI, a cada pull request). Cada arquivo é uma query que lista os registros que quebram a regra. +Regras sobre os **valores** de pedidos, itens e pagamentos que não fazem parte dos 8 defeitos investigados, mas que o `npm run validate` confere a cada execução (e a CI, a cada pull request). Cada arquivo é uma query que lista os registros que quebram a regra. | Arquivo | Regra | Massa válida | Massa quebrada | |---|---|---|---| From eb282707a50b09dcfcb09f8fe136be0b2eb672f7 Mon Sep 17 00:00:00 2001 From: ThomasTDS Date: Mon, 19 Oct 2026 14:33:36 -0300 Subject: [PATCH 2/2] Investigacao 08: passo 3 so com pares acima do limite padrao A similaridade da pg_trgm depende do locale do banco para caracteres fora do ASCII: o par de nomes com texto quebrado da investigacao 07 dava 0,297 no Windows e 0,286 no Linux da CI, e o teste de regressao dos relatorios falhou. O passo 3 passa a listar so os pares acima do limite padrao da extensao (0,3), que sao os da discussao de falsos positivos e dao o mesmo valor nos dois ambientes. O relatorio explica a dependencia do locale. --- investigacoes/08-duplicidade-aproximada/README.md | 11 +++++------ .../08-duplicidade-aproximada/exploracao.sql | 10 ++++++---- .../08-duplicidade-aproximada/resultado-esperado.json | 4 +--- 3 files changed, 12 insertions(+), 13 deletions(-) diff --git a/investigacoes/08-duplicidade-aproximada/README.md b/investigacoes/08-duplicidade-aproximada/README.md index a035ec7..38b7c98 100644 --- a/investigacoes/08-duplicidade-aproximada/README.md +++ b/investigacoes/08-duplicidade-aproximada/README.md @@ -76,15 +76,15 @@ WHERE id IN (5, 9); ### Passo 3: similaridade entre todos os pares -Para achar nomes **parecidos**, a extensão `pg_trgm` do PostgreSQL quebra cada nome em sequências de 3 letras (trigramas) e mede a fração em comum: 0 é nada em comum, 1 é igual. Ela já ignora maiúsculas e pontuação, e um erro de digitação só afeta alguns trigramas. Para todos os pares de produtos: +Para achar nomes **parecidos**, a extensão `pg_trgm` do PostgreSQL quebra cada nome em sequências de 3 letras (trigramas) e mede a fração em comum: 0 é nada em comum, 1 é igual. Ela já ignora maiúsculas e pontuação, e um erro de digitação só afeta alguns trigramas. A extensão tem um limite padrão (o do operador `%`) de **0.3**: pares acima dele são considerados parecidos. Os pares de produtos acima desse limite: ```sql SELECT a.id AS produto_a, b.id AS produto_b, a.nome AS nome_a, b.nome AS nome_b, round(similarity(a.nome, b.nome)::numeric, 3) AS similaridade FROM produtos a JOIN produtos b ON a.id < b.id -ORDER BY similarity(a.nome, b.nome) DESC -LIMIT 6; +WHERE similarity(a.nome, b.nome) >= 0.3 +ORDER BY similarity(a.nome, b.nome) DESC; ``` | produto_a | produto_b | nome_a | nome_b | similaridade | @@ -93,14 +93,13 @@ LIMIT 6; | 1 | 2 | Plano Básico Mensal | Plano Profissional Mensal | 0.419 | | 1 | 3 | Plano Básico Mensal | Plano Enterprise Mensal | 0.419 | | 2 | 3 | Plano Profissional Mensal | Plano Enterprise Mensal | 0.371 | -| 6 | 7 | Módulo de Relatórios | Módulo de Integrações | 0.297 | -| 4 | 6 | Pacote de Onboarding | Módulo de Relatórios | 0.073 | **Achados:** - **H2 confirmada:** o par `5` e `9` tem similaridade **0.808**, muito acima de todos os outros. -- **A escolha do limite importa.** Os três planos ("Plano Básico Mensal", "Plano Profissional Mensal", "Plano Enterprise Mensal") são produtos **legítimos e diferentes**, mas compartilham "Plano" e "Mensal" e chegam a **0.419**. O limite padrão da `pg_trgm` (o operador `%`) é **0.3**, e com ele os três pares de planos seriam marcados como duplicados: três falsos positivos para um caso real. +- **A escolha do limite importa.** Os três planos ("Plano Básico Mensal", "Plano Profissional Mensal", "Plano Enterprise Mensal") são produtos **legítimos e diferentes**, mas compartilham "Plano" e "Mensal" e chegam a **0.419**. Com o limite padrão de 0.3, os três pares de planos seriam marcados como duplicados: três falsos positivos para um caso real. - **O limite foi definido pelos dados:** 0.6 fica no meio do intervalo entre o maior par legítimo (0.419) e o duplicado (0.808). Num catálogo maior, esse intervalo pode ser menor, e o resultado da detecção deve ser tratado como **lista de suspeitos para revisão**, e não como certeza. +- **A similaridade depende do locale do banco.** A `pg_trgm` decide o que conta como "letra" a partir do locale do banco, e isso muda o resultado para caracteres fora do ASCII. O par "Módulo de Relatórios" × "Módulo de Integrações" (texto quebrado da investigação 07) dá **0.297** num banco com locale português (Windows) e **0.286** num banco Linux. O teste de regressão dos relatórios pegou essa diferença na primeira execução da CI. Os valores que sustentam a conclusão (0.808, 0.419 e 0.371) são **iguais** nos dois ambientes, e o par divergente fica abaixo do limite padrão, fora da tabela. Na prática, um limite escolhido num ambiente deve ser validado no ambiente onde a detecção vai rodar, principalmente com nomes acentuados. ### Passo 4: a detecção final — é isolado? diff --git a/investigacoes/08-duplicidade-aproximada/exploracao.sql b/investigacoes/08-duplicidade-aproximada/exploracao.sql index 036a53f..ce3f852 100644 --- a/investigacoes/08-duplicidade-aproximada/exploracao.sql +++ b/investigacoes/08-duplicidade-aproximada/exploracao.sql @@ -25,8 +25,10 @@ FROM produtos WHERE id IN (5, 9) ORDER BY id; --- Passo 3: similaridade entre todos os pares de produtos, da maior para a --- menor (as 6 maiores). +-- Passo 3: pares de produtos que o limite padrão da extensão (0,3) +-- consideraria parecidos, da maior para a menor similaridade. +-- (Abaixo de 0,3, o valor de pares com caracteres acentuados ou quebrados +-- varia com o locale do banco; ver o relatório.) SELECT a.id AS produto_a, b.id AS produto_b, @@ -35,8 +37,8 @@ SELECT round(similarity(a.nome, b.nome)::numeric, 3) AS similaridade FROM produtos a JOIN produtos b ON a.id < b.id -ORDER BY similarity(a.nome, b.nome) DESC, a.id, b.id -LIMIT 6; +WHERE similarity(a.nome, b.nome) >= 0.3 +ORDER BY similarity(a.nome, b.nome) DESC, a.id, b.id; -- Passo 4: detecção final (mesma query de deteccao.sql). SELECT diff --git a/investigacoes/08-duplicidade-aproximada/resultado-esperado.json b/investigacoes/08-duplicidade-aproximada/resultado-esperado.json index 7940f23..1e3ed91 100644 --- a/investigacoes/08-duplicidade-aproximada/resultado-esperado.json +++ b/investigacoes/08-duplicidade-aproximada/resultado-esperado.json @@ -29,9 +29,7 @@ ["5","9","Consultoria Avulsa (hora)","Consutoria avulsa - hora","0.808"], ["1","2","Plano Básico Mensal","Plano Profissional Mensal","0.419"], ["1","3","Plano Básico Mensal","Plano Enterprise Mensal","0.419"], - ["2","3","Plano Profissional Mensal","Plano Enterprise Mensal","0.371"], - ["6","7","Módulo de Relatórios","Módulo de Integrações","0.297"], - ["4","6","Pacote de Onboarding","Módulo de Relatórios","0.073"] + ["2","3","Plano Profissional Mensal","Plano Enterprise Mensal","0.371"] ] }, {