Compartir a través de

Inicio rápido: Uso del explicador de lógica de negocios

En esta guía rápida, aprenderá cómo el explicador de lógica de negocios ayuda a los desarrolladores a comprender y trabajar con una lógica de aplicación compleja implementada en marcos de SQL, asignación objeto-relacional (ORM) o directamente en la base de datos. El asistente analiza el código SQL, los modelos ORM o los esquemas de base de datos existentes para explicar las reglas de negocio subyacentes y proporcionar documentación accionable.

Comienza

Asegúrese de que está conectado a una base de datos y de que tiene abierta una ventana del editor activa con la extensión MSSQL. Esta conexión permite al participante del @mssql chat comprender el contexto del entorno de base de datos, lo que permite sugerencias precisas y compatibles con el contexto. Sin una conexión de base de datos, el participante del chat no tendrá el esquema ni el contexto de datos para proporcionar respuestas significativas.

En los ejemplos siguientes se usa la AdventureWorksLT2022 base de datos de ejemplo, que puede descargar desde la página principal Ejemplos de Microsoft SQL Server y Proyectos de comunidad .

Para obtener los mejores resultados, ajuste los nombres de tabla y esquema para que coincidan con su propio entorno.

Asegúrese de que el chat incluye el @mssql prefijo. Por ejemplo, escriba @mssql seguido de su pregunta o indicador. Esto garantiza que el participante del chat comprenda que solicita ayuda relacionada con SQL.

Descripción de la lógica de negocios con GitHub Copilot

GitHub Copilot puede ayudarle a comprender y explicar las reglas de negocio insertadas en el código de base de datos, los modelos ORM y las consultas de aplicaciones. Desde procedimientos almacenados a consultas LINQ y sequelize expressions, GitHub Copilot proporciona información de lenguaje natural para que la lógica compleja sea más accesible.

Estos son casos de uso comunes y ejemplos de lo que puede preguntar a través del participante del chat:

Explicación de la lógica de T-SQL

Use GitHub Copilot para comprender y explicar la lógica de Transact-SQL (T-SQL), desde procedimientos almacenados hasta instrucciones condicionales insertadas. Tanto si está revisando reglas de descuento, lógica de procedimientos o condiciones de optimización, GitHub Copilot puede analizar y documentar las reglas de negocio implementadas en T-SQL.

Explicación de un procedimiento almacenado

Explain what the `SalesLT.uspGetCustomerOrderHistory` stored procedure does and suggest ways to optimize it.

Depura un procedimiento almacenado

Debug the `SalesLT.uspGetTopSellingProducts` stored procedure and suggest improvements.

Explicación de la lógica de negocios en un fragmento de código

Analyze the following SQL code snippet from my current database. Document the business rules implemented in this discount application process, including conditions for eligibility, discount rate adjustments, and any limits imposed on the discount amount. Also, provide actionable insights or suggestions to improve clarity or performance if necessary.

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;

Explicación de la lógica ORM

Explicación de una consulta SQLAlchemy

Explain what the following SQLAlchemy query does:

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)
)

Explicación de una consulta LINQ de Entity Framework

What does this Entity Framework LINQ query do? Describe how it groups customers by tier based on their total purchases.

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"
    });

Explicación de la lógica de negocios en una consulta prisma

Analyze the logic of this Prisma query and explain how it determines which products are considered "low inventory".

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

Explicar y comentar una consulta Dequelize

Review and explain what this Sequelize query does. Add inline comments to clarify how it calculates total revenue per customer and filters for customers with significant spending:

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

Generación de una consulta SQLAlchemy para obtener una lista de productos

Using SQLAlchemy, generate a query to list products that have never been ordered and ask GitHub Copilot to explain the join logic and filtering behavior.

Recuperación de la información del cliente mediante una consulta prisma

In Prisma, write a query that retrieves customers who placed an order in the last 30 days. Explain what the following Prisma query does. Add inline comments to clarify how the date filtering works and how recent orders are determined:

Descripción de la intención empresarial a través de consultas

GitHub Copilot ayuda a los desarrolladores a comprender no solo cómo funciona una consulta, sino por qué existe. Esta explicación incluye el propósito real detrás de filtros de datos, agrupaciones y agregaciones. Estas explicaciones son especialmente útiles durante la incorporación, lo que permite a los desarrolladores comprender los objetivos subyacentes a informes, puertas lógicas o métricas del sistema insertadas en código SQL y ORM.

Describir los objetivos empresariales en una consulta de T-SQL

Describe the business goal of the following SQL query. What insight is it trying to surface?

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

Resumen de la intención de una consulta de T-SQL

Summarize what this query is intended to achieve from a business perspective.

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

Describir la lógica de negocios en un procedimiento almacenado

Analyze the `SalesLT.uspGetCustomerOrderHistory` stored procedure and describe the business logic it implements.

Explicación de la lógica de negocios en una consulta LINQ de Entity Framework

Explain this Entity Framework LINQ query and describe what business logic it implements:

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();

Explicar las suposiciones empresariales en una consulta Sequelize

Using Sequelize, explain what this query does and describe any business assumptions it makes:

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

Compartir la experiencia

Para ayudarnos a refinar y mejorar GitHub Copilot para la extensión MSSQL, use la siguiente plantilla de problema de GitHub para enviar sus comentarios: Comentarios de GitHub Copilot

Al enviar comentarios, considere la posibilidad de incluir:

  • Escenarios probados : háganos saber en qué áreas se ha centrado, por ejemplo, la creación de esquemas, la generación de consultas, la seguridad, la localización.

  • Lo que funcionó bien : describa cualquier experiencia que se sintiera suave, útil o superara sus expectativas.

  • Problemas o errores : incluya cualquier problema, incoherencias o comportamientos confusos. Las capturas de pantalla o las grabaciones de pantalla son especialmente útiles.

  • Sugerencias para mejorar : comparta ideas para mejorar la facilidad de uso, expandir la cobertura o mejorar las respuestas de GitHub Copilot.

Contenido relacionado

  • Last updated on