Delen via

Quickstart: De uitleg over bedrijfslogica gebruiken

In deze quickstart leer je hoe de bedrijfslogica-uitlegger ontwikkelaars helpt complexe toepassingslogica te begrijpen en ermee te werken, geïmplementeerd in SQL, ORM-frameworks (Object-Relational Mapping) of rechtstreeks in de database. De assistent analyseert SQL-code, ORM-modellen of bestaande databaseschema's om de onderliggende bedrijfsregels uit te leggen en bruikbare documentatie te bieden.

Aan de slag

Zorg ervoor dat u verbinding hebt met een database en een actief editorvenster hebt geopend met de MSSQL-extensie. Met deze verbinding kan de @mssql chatdeelnemer de context van uw databaseomgeving begrijpen en nauwkeurige en contextbewuste suggesties inschakelen. Zonder een databaseverbinding beschikt de chatdeelnemer niet over het schema of de gegevenscontext om zinvolle antwoorden te geven.

In de volgende voorbeelden wordt de AdventureWorksLT2022 voorbeelddatabase gebruikt, die u kunt downloaden van de startpagina van Microsoft SQL Server Samples en Community Projects .

Pas voor de beste resultaten de tabel- en schemanamen aan zodat deze overeenkomen met uw eigen omgeving.

Zorg ervoor dat de chat het @mssql voorvoegsel bevat. Typ bijvoorbeeld @mssql gevolgd door uw vraag of prompt. Dit zorgt ervoor dat de chatdeelnemer begrijpt dat u vraagt om hulp met betrekking tot SQL.

Inzicht in bedrijfslogica met GitHub Copilot

GitHub Copilot kan u helpen bij het begrijpen en uitleggen van bedrijfsregels die zijn ingesloten in databasecode, ORM-modellen en toepassingsquery's. Van opgeslagen procedures tot LINQ-query's en Sequelize-expressies biedt GitHub Copilot natuurlijke taalinzichten om complexere logica toegankelijker te maken.

Hier volgen veelvoorkomende gebruiksvoorbeelden en voorbeelden van wat u kunt vragen via de chatdeelnemer:

T-SQL-logica uitleggen

Gebruik GitHub Copilot om Transact-SQL (T-SQL)-logica te begrijpen en uit te leggen, van opgeslagen procedures tot inline voorwaardelijke instructies. Ongeacht of u kortingsregels, procedurele logica of optimalisatievoorwaarden bekijkt, kan GitHub Copilot bedrijfsregels analyseren en documenteren die zijn geïmplementeerd in T-SQL.

Een opgeslagen procedure uitleggen

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

Fouten opsporen in een opgeslagen procedure

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

Bedrijfslogica uitleggen in een codefragment

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;

ORM-logica uitleggen

Een SQLAlchemy-query uitleggen

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

Een Entity Framework LINQ-query uitleggen

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

De bedrijfslogica in een Prisma-query uitleggen

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

Een sequelize-query uitleggen en er opmerkingen bij plaatsen

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

Een SQLAlchemy-query genereren voor een lijst met producten

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.

Klantgegevens ophalen met behulp van een Prisma-query

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:

Inzicht in bedrijfsintentie via query's

GitHub Copilot helpt ontwikkelaars niet alleen te begrijpen hoe een query werkt, maar waarom deze bestaat. Deze uitleg omvat het echte doel achter gegevensfilters, groeperingen en aggregaties. Deze uitleg is vooral nuttig tijdens het onboarden, zodat ontwikkelaars de doelen achter rapporten, logische poorten of systeemstatistieken die zijn ingesloten in SQL- en ORM-code, kunnen begrijpen.

De bedrijfsdoelen in een T-SQL-query beschrijven

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;

De intentie van een T-SQL-query samenvatten

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;

Bedrijfslogica beschrijven in een opgeslagen procedure

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

Bedrijfslogica uitleggen in een Entity Framework LINQ-query

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

Bedrijfsveronderstellingen uitleggen in een sequelize-query

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

Uw ervaring delen

Om ons te helpen GitHub Copilot voor de MSSQL-extensie te verfijnen en te verbeteren, gebruikt u de volgende GitHub-probleemsjabloon om uw feedback te verzenden: GitHub Copilot-feedback

Overweeg het volgende bij het indienen van feedback:

  • Geteste scenario's : laat ons weten op welke gebieden u zich richt, bijvoorbeeld het maken van schema's, het genereren van query's, beveiliging, lokalisatie.

  • Wat goed werkte – Beschrijf ervaringen die soepel aanvoelden, behulpzaam waren of uw verwachtingen overtroffen.

  • Problemen of bugs : neem eventuele problemen, inconsistenties of verwarrend gedrag op. Screenshots of schermopnamen zijn vooral nuttig.

  • Suggesties voor verbetering : deel ideeën voor het verbeteren van bruikbaarheid, het uitbreiden van de dekking of het verbeteren van de reacties van GitHub Copilot.

Verwante inhoud

  • Last updated on