Guia de início rápido: usar o Explicador de Lógica Empresarial (Visualização)

2025-05-20

Neste guia de início rápido, você aprenderá como o Business Logic Explainer ajuda os desenvolvedores a entender e trabalhar com lógica de aplicativo complexa implementada em SQL, estruturas ORM (Object-Relational Mapping) ou diretamente no banco de dados. O assistente analisa o código SQL, modelos ORM ou esquemas de banco de dados existentes para explicar as regras de negócios subjacentes e fornecer documentação acionável.

Comece

Verifique se você está conectado a um banco de dados e se uma janela do editor ativo está aberta com a extensão MSSQL. Essa conexão permite que o participante do bate-papo @mssql compreenda o contexto do seu ambiente de banco de dados, permitindo sugestões precisas e sensíveis ao contexto. Sem uma conexão de banco de dados, o participante do bate-papo não terá o esquema ou o contexto de dados para fornecer respostas significativas.

Os exemplos a seguir usam o AdventureWorksLT2022 banco de dados de exemplo, que você pode baixar da home page de Exemplos e Projetos da Comunidade do Microsoft SQL Server .

Para obter melhores resultados, ajuste os nomes de tabelas e esquemas para corresponder ao seu próprio ambiente.

Certifique-se de que o chat inclui o prefixo @mssql . Por exemplo, digite @mssql seguido de a sua pergunta ou solicitação. Isso garante que o participante do bate-papo entenda que você está solicitando assistência relacionada ao SQL.

Entenda a lógica de negócios com o GitHub Copilot

O GitHub Copilot pode ajudá-lo a entender e explicar as regras de negócios incorporadas no código do banco de dados, modelos ORM e consultas de aplicativos. De procedimentos armazenados a consultas LINQ e expressões Sequelize, o GitHub Copilot fornece insights de linguagem natural para tornar a lógica complexa mais acessível.

Aqui estão casos de uso comuns e exemplos do que você pode perguntar através do participante do bate-papo:

Explicar a lógica T-SQL

Use o GitHub Copilot para entender e explicar a lógica T-SQL, desde procedimentos armazenados até instruções condicionais embutidas. Se você está revisando regras de desconto, lógica processual ou condições de otimização, o GitHub Copilot pode analisar e documentar regras de negócios implementadas no T-SQL.

Explique o que o SalesLT.uspGetCustomerOrderHistory procedimento armazenado faz e sugira maneiras de otimizá-lo.
Depure o SalesLT.uspGetTopSellingProducts procedimento armazenado e sugira melhorias.
Analise o seguinte SQL trecho de código do meu banco de dados atual. Documente as regras de negócio implementadas neste processo de pedido de desconto, incluindo condições de elegibilidade, ajustes da taxa de desconto e quaisquer limites impostos ao valor do desconto. Além disso, forneça informações ou sugestões acionáveis para melhorar a clareza ou o desempenho, se necessário.

DECLARE @OrderTotal AS DECIMAL (10, 2) = 1500.00;
DECLARE @DiscountCode AS NVARCHAR (20) = 'DISCOUNT10';
DECLARE @DiscountPct AS DECIMAL (5, 2) = CASE WHEN @OrderTotal > 1000.00 THEN 5.0 ELSE 0.0 END;

IF @DiscountCode = 'DISCOUNT10'
    BEGIN
        SET @DiscountPct = CASE WHEN @DiscountPct < 10.0 THEN 10.0 ELSE @DiscountPct END;
    END

DECLARE @DiscountAmount AS DECIMAL (10, 2) = (@OrderTotal * @DiscountPct / 100.0);

IF @DiscountAmount > 200.00
    BEGIN
        SET @DiscountAmount = 200.00;
    END

SELECT @OrderTotal AS OrderTotal,
       @DiscountPct AS DiscountPercentage,
       @DiscountAmount AS DiscountAmount;

Explicar a lógica ORM

Explique o que faz a seguinte consulta SQLAlchemy:

from sqlalchemy import func

top_customers = (
    session.query(SalesOrderHeader.CustomerID, func.count().label("OrderCount"))
    .group_by(SalesOrderHeader.CustomerID)
    .order_by(func.count().desc())
    .limit(10)
)

O que faz esta consulta LINQ do Entity Framework? Descreva como ele agrupa os clientes por nível com base no total de compras.

var customerTiers = context.SalesOrderHeaders
    .GroupBy(o => o.CustomerID)
    .Select(g => new {
        CustomerID = g.Key,
        TotalSpent = g.Sum(o => o.TotalDue),
        Tier = g.Sum(o => o.TotalDue) >= 10000 ? "Gold" :
               g.Sum(o => o.TotalDue) >= 5000 ? "Silver" : "Bronze"
    });

Analise a lógica desta consulta Prisma e explique como ela determina quais produtos são considerados "baixo estoque".

const lowInventoryProducts = await prisma.product.findMany({
  where: {
    SafetyStockLevel: {
      lt: 50
    }
  },
  select: {
    ProductID: true,
    Name: true,
    SafetyStockLevel: true
  }
});

Analise e explique o que esta consulta Sequelize faz. Adicione comentários embutidos para esclarecer como calcula a receita total por cliente e filtra para clientes com gastos significativos:

const results = await SalesOrderHeader.findAll({
  attributes: ['CustomerID', [sequelize.fn('SUM', sequelize.col('TotalDue')), 'TotalSpent']],
  group: ['CustomerID'],
  having: sequelize.literal('SUM(TotalDue) > 5000')
});

Usando SQLAlchemy, gere uma consulta para listar produtos que nunca foram encomendados e peça ao GitHub Copilot para explicar a lógica de junção e o comportamento de filtragem.
No Prisma, escreva uma consulta que recupere clientes que fizeram um pedido nos últimos 30 dias. Explique o que faz a consulta Prisma a seguir. Adicione comentários embutidos para esclarecer como funciona a filtragem de data e como os pedidos recentes são determinados:

Compreender a intenção de negócios por meio de consultas

O GitHub Copilot ajuda os desenvolvedores a entender não apenas como uma consulta funciona, mas por que ela existe. Isso inclui o propósito real por trás de filtros, agrupamentos e agregações de dados. Essas explicações são especialmente úteis durante a integração, permitindo que os desenvolvedores compreendam os objetivos por trás de relatórios, portas lógicas ou métricas do sistema incorporadas em código SQL e ORM.

Descreva o objetivo comercial da consulta SQL a seguir. Que perspetiva está tentando revelar?

SELECT TOP 10 CustomerID,
              COUNT(*) AS OrderCount
FROM SalesLT.SalesOrderHeader
GROUP BY CustomerID
ORDER BY OrderCount DESC;

Resuma o que esta consulta pretende alcançar de uma perspetiva de negócios.

SELECT ProductID,
       SUM(LineTotal) AS TotalSales
FROM SalesLT.SalesOrderDetail
GROUP BY ProductID
HAVING SUM(LineTotal) > 10000;

Analise o SalesLT.uspGetCustomerOrderHistory procedimento armazenado e descreva a lógica de negócios que ele implementa.
Explique essa consulta LINQ do Entity Framework e descreva qual lógica de negócios ela implementa:

var highValueCustomers = context.SalesOrderHeaders
    .Where(o => o.TotalDue > 1000)
    .GroupBy(o => o.CustomerID)
    .Select(g => new { CustomerID = g.Key, OrderCount = g.Count() })
    .OrderByDescending(x => x.OrderCount)
    .Take(10)
    .ToList();

Usando Sequelize, explique o que esta consulta faz e descreva todas as suposições comerciais que ela faz.

const customerRevenue = await SalesOrderHeader.findAll({
  attributes: ['CustomerID', [sequelize.fn('SUM', sequelize.col('TotalDue')), 'TotalSpent']],
  group: ['CustomerID'],
  having: sequelize.literal('SUM(TotalDue) > 5000')
});

Feedback: Explicador de lógica de negócios

Para nos ajudar a refinar e melhorar o Copilot do GitHub para a extensão MSSQL, use o seguinte modelo de problema do GitHub para enviar seus comentários: Feedback do Copiloto do GitHub

Ao enviar comentários, considere incluir:

Cenários testados – Diga-nos em quais áreas você se focou, por exemplo, criação de esquema, geração de consultas, segurança, localização.
O que funcionou bem – Descreva todas as experiências que foram suaves, úteis ou que excederam as suas expectativas.
Problemas ou bugs – Inclua quaisquer problemas, inconsistências ou comportamentos confusos. Capturas de tela ou gravações de tela são especialmente úteis.
Sugestões de melhoria – Compartilhe ideias para melhorar a usabilidade, expandir a cobertura ou melhorar as respostas do Copiloto do GitHub.

Partilhar via