Partager via

Démarrage rapide : Utiliser l’explicatif de logique métier

Dans ce guide de démarrage rapide, vous allez découvrir comment l’explicatif de logique métier aide les développeurs à comprendre et à utiliser une logique d’application complexe implémentée dans les infrastructures SQL, ORM (Object-Relational Mapping) ou directement dans la base de données. L’assistant analyse le code SQL, les modèles ORM ou les schémas de base de données existants pour expliquer les règles métier sous-jacentes et fournir une documentation exploitable.

Commencez

Vérifiez que vous êtes connecté à une base de données et que vous disposez d’une fenêtre d’éditeur active ouverte avec l’extension MSSQL. Cette connexion permet au @mssql participant au chat de comprendre le contexte de votre environnement de base de données, ce qui permet des suggestions précises et adaptées au contexte. Sans connexion de base de données, le participant de conversation ne dispose pas du schéma ou du contexte de données pour fournir des réponses significatives.

Les exemples suivants utilisent l’exemple AdventureWorksLT2022 de base de données, que vous pouvez télécharger à partir de la page d’accueil Exemples microsoft SQL Server et Projets communautaires .

Pour obtenir de meilleurs résultats, ajustez les noms de table et de schéma pour qu’ils correspondent à votre propre environnement.

Assurez-vous que la conversation inclut le @mssql préfixe. Par exemple, tapez @mssql suivi de votre question ou de votre invite. Cela garantit que le participant de conversation comprend que vous demandez de l’aide liée à SQL.

Comprendre la logique métier avec GitHub Copilot

GitHub Copilot peut vous aider à comprendre et à expliquer les règles métier incorporées dans le code de base de données, les modèles ORM et les requêtes d’application. Des procédures stockées aux requêtes LINQ et aux expressions Sequelize, GitHub Copilot fournit des insights en langage naturel pour rendre la logique complexe plus accessible.

Voici des cas d’usage courants et des exemples de ce que vous pouvez demander via le participant de conversation :

Expliquer la logique T-SQL

Utilisez GitHub Copilot pour comprendre et expliquer la logique Transact-SQL (T-SQL), des procédures stockées aux instructions conditionnelles inline. Que vous examiniez des règles de remise, une logique procédurale ou des conditions d’optimisation, GitHub Copilot peut analyser et documenter les règles métier implémentées dans T-SQL.

Expliquer une procédure stockée

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

Déboguer une procédure stockée

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

Expliquer la logique métier dans un extrait de code

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;

Expliquer la logique ORM

Expliquer une requête 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)
)

Expliquer une requête ENTITY Framework LINQ

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

Expliquer la logique métier dans une requête 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
  }
});

Expliquer et commenter une requête Sequelize

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

Générer une requête SQLAlchemy pour une liste de produits

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.

Récupérer des informations client à l’aide d’une requête 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:

Comprendre l’intention métier par le biais de requêtes

GitHub Copilot aide les développeurs à comprendre non seulement comment fonctionne une requête, mais pourquoi elle existe. Cette explication inclut l’objectif réel derrière les filtres de données, les regroupements et les agrégations. Ces explications sont particulièrement utiles lors de l’intégration, ce qui permet aux développeurs de saisir les objectifs derrière les rapports, les portes logiques ou les métriques système incorporées dans le code SQL et ORM.

Décrire les objectifs métier dans une requête 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;

Résumer l’intention d’une requête 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;

Décrire la logique métier dans une procédure stockée

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

Expliquer la logique métier dans une requête LINQ 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();

Expliquer les hypothèses métier dans une requête 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')
});

Partager votre expérience

Pour nous aider à affiner et améliorer GitHub Copilot pour l’extension MSSQL, utilisez le modèle de problème GitHub suivant pour envoyer vos commentaires : Commentaires GitHub Copilot

Lors de l’envoi de commentaires, envisagez d’inclure :

  • Scénarios testés : informez-nous des domaines sur lesquels vous vous êtes concentré, par exemple, la création de schéma, la génération de requêtes, la sécurité, la localisation.

  • Ce qui a bien fonctionné – Décrivez toutes les expériences qui ont semblé fluides, utiles ou ont dépassé vos attentes.

  • Problèmes ou bogues : incluez des problèmes, des incohérences ou des comportements déroutants. Les captures d’écran ou les enregistrements d’écran sont particulièrement utiles.

  • Suggestions d’amélioration : partagez des idées pour améliorer la facilité d’utilisation, développer la couverture ou améliorer les réponses de GitHub Copilot.

Contenu connexe

  • Last updated on