Condividi tramite

Guida introduttiva: Usare lo spiegatore della logica di business

In questo argomento di avvio rapido si apprenderà come lo spiegatore della logica di business consente agli sviluppatori di comprendere e usare la logica dell'applicazione complessa implementata nei framework SQL, ORM (Object-Relational Mapping) o direttamente nel database. L'assistente analizza il codice SQL, i modelli ORM o gli schemi di database esistenti per spiegare le regole business sottostanti e fornire documentazione pratica.

Inizia subito

Assicurarsi di essere connessi a un database e di aprire una finestra dell'editor attivo con l'estensione MSSQL. Questa connessione consente al partecipante della @mssql chat di comprendere il contesto dell'ambiente di database, abilitando suggerimenti accurati e con riconoscimento del contesto. Senza una connessione al database, il partecipante della chat non avrà lo schema o il contesto dei dati per fornire risposte significative.

Gli esempi seguenti usano il AdventureWorksLT2022 database di esempio, che è possibile scaricare dalla home page degli esempi di Microsoft SQL Server e dei progetti della community .

Per ottenere risultati ottimali, modificare i nomi di tabella e schema in modo che corrispondano al proprio ambiente.

Assicurarsi che la chat includa il @mssql prefisso. Ad esempio, digitare @mssql seguito dalla domanda o dal prompt. Ciò garantisce che il partecipante della chat comprenda che si sta chiedendo assistenza correlata a SQL.

Comprendere la logica di business con GitHub Copilot

GitHub Copilot consente di comprendere e spiegare le regole business incorporate nel codice del database, nei modelli ORM e nelle query dell'applicazione. Dalle stored procedure alle query LINQ e alle espressioni Sequelize, GitHub Copilot offre informazioni dettagliate sul linguaggio naturale per rendere più accessibile la logica complessa.

Di seguito sono riportati casi d'uso comuni ed esempi di ciò che è possibile chiedere tramite il partecipante alla chat:

Spiegare la logica T-SQL

Usare GitHub Copilot per comprendere e spiegare la logica di Transact-SQL (T-SQL), dalle procedure archiviate alle istruzioni condizionali in linea. Indipendentemente dal fatto che si esaminino regole di sconto, logica procedurale o condizioni di ottimizzazione, GitHub Copilot può analizzare e documentare le regole business implementate in T-SQL.

Spiegare una procedura archiviata

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

Eseguire il debug di una stored procedure

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

Spiegare la logica di business in un frammento di codice

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;

Spiegare la logica ORM

Spiegare una query 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)
)

Spiegare una query LINQ di 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"
    });

Spiegare la logica aziendale all'interno di una query 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
  }
});

Spiegare e commentare una query 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')
});

Generare una query SQLAlchemy per un elenco di prodotti

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.

Recuperare informazioni sui clienti usando una query 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:

Comprendere l'intento aziendale dalle query

GitHub Copilot aiuta gli sviluppatori a capire non solo come funziona una query, ma perché esiste. Questa spiegazione include lo scopo reale dietro filtri dati, raggruppamenti e aggregazioni. Queste spiegazioni sono particolarmente utili durante l'onboarding, consentendo agli sviluppatori di comprendere gli obiettivi alla base di report, gate logici o metriche di sistema incorporate nel codice SQL e ORM.

Descrivere gli obiettivi aziendali in una query 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;

Riepilogare l'intenzione di una query 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;

Descrivere la logica aziendale in una stored procedure

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

Spiegare la logica di business in una query LINQ di 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();

Spiegare i presupposti aziendali in una query 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')
});

Condividere la propria esperienza

Per ottimizzare e migliorare GitHub Copilot per l'estensione MSSQL, usare il modello di problema GitHub seguente per inviare commenti e suggerimenti: Commenti e suggerimenti su GitHub Copilot

Quando si inviano commenti e suggerimenti, è consigliabile includere:

  • Scenari testati: segnalare le aree su cui ci si è concentrati, ad esempio la creazione dello schema, la generazione di query, la sicurezza, la localizzazione.

  • Cosa ha funzionato bene : descrivere tutte le esperienze che si sono sentite fluide, utili o superate le aspettative.

  • Problemi o bug : includere eventuali problemi, incoerenze o comportamenti confusi. Screenshot o registrazioni dello schermo sono particolarmente utili.

  • Suggerimenti per il miglioramento : condividere idee per migliorare l'usabilità, espandere la copertura o migliorare le risposte di GitHub Copilot.

Contenuti correlati

  • Last updated on