Guida introduttiva: Assistente dell'Ottimizzatore di Query

GitHub Copilot consente agli sviluppatori di ottimizzare le query e analizzare i colli di bottiglia delle prestazioni senza bisogno di competenze nei dettagli interni dei database, in particolare agli sviluppatori senza competenze approfondite di Transact-SQL (T-SQL). GitHub Copilot può scomporre SQL complessi, interpretare i piani di esecuzione e suggerire strategie di indicizzazione o opportunità di refactoring. Gli sviluppatori possono mantenere le proprie app funzionali e performanti, rimanendo concentrati sulla distribuzione delle funzionalità.

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.

Ottimizzare le prestazioni con GitHub Copilot

GitHub Copilot offre diversi modi per aiutare gli sviluppatori a scrivere codice di database con prestazioni elevate e pronte per la produzione senza richiedere competenze approfondite nell'ottimizzazione delle query o nell'analisi del piano di esecuzione. Che si stia creando nuove funzionalità o analizzando un problema di prestazioni, GitHub Copilot può visualizzare informazioni dettagliate, consigliare ottimizzazioni e aiutare a ristrutturare le query, tutto all'interno del flusso di lavoro esistente in Visual Studio Code.

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

Ottimizzare le interrogazioni

Usare GitHub Copilot per identificare le inefficienze nelle query SQL o ORM (Object-Relational Mapping) e suggerire modi per migliorare le prestazioni. GitHub Copilot aiuta ad applicare le migliori pratiche per T-SQL e ORM, dalla riscrittura di query lente alla raccomandazione di indici o all'evitamento di anti-pattern come i join cartesiani, in base al contesto corrente.

Esempio di base

Optimize the following query:

SELECT *
FROM SalesLT.SalesOrderHeader
WHERE OrderDate > '2023-01-01';

Esempio di miglioramento dell'indice

Suggest indexing improvements for this query:

SELECT ProductID
FROM SalesLT.SalesOrderDetail
WHERE Quantity > 100;

Esempio di miglioramento dell'unione

Rewrite this query to avoid a Cartesian join. Make sure the new query follows T-SQL best practices:

SELECT * FROM Customers, Order;

Esempio di selezione nidificata

Rewrite this Prisma query to avoid unnecessary nested selects and improve readability:

const orders = await prisma.salesOrderHeader.findMany({
  where: {
    orderDate: {
      gt: new Date('2023-01-01')
    }
  }
});

Analisi del piano di esecuzione

I piani di esecuzione forniscono una suddivisione dettagliata del modo in cui il motore SQL elabora le query. GitHub Copilot consente di interpretare i piani di esecuzione, identificare colli di bottiglia come i join a cicli annidati e suggerire miglioramenti basati su modelli di query reali e strategie di indicizzazione.

È possibile usare la query seguente come esempio per generare il piano di esecuzione usando l'opzione Piano stimato/effettivo nell'estensione MSSQL:

SELECT soh1.SalesOrderID AS OrderA,
       soh2.SalesOrderID AS OrderB,
       soh1.TotalDue AS TotalA,
       soh2.TotalDue AS TotalB
FROM SalesLT.SalesOrderHeader AS soh1
    CROSS JOIN SalesLT.SalesOrderHeader AS soh2
WHERE soh1.TotalDue < soh2.TotalDue
ORDER BY soh2.TotalDue DESC;

Includere il più possibile il contesto selezionando la query dall'editor e includendo il sqlplan file nella finestra di chat di GitHub Copilot, come illustrato in questo screenshot.

According to the execution plan shared by my database expert, the following query is using a nested loop join which is affecting the performance of my app. Can you explain in simple terms why this might be happening? Additionally, suggest optimization strategies that could improve the query's performance.

È possibile usare la query seguente come esempio per generare il piano di esecuzione usando l'opzione Piano stimato/effettivo nell'estensione MSSQL:

SELECT c1.CustomerID,
       c1.LastName,
       c2.CustomerID AS MatchingCustomerID,
       c2.LastName AS MatchingLastName
FROM SalesLT.Customer AS c1
     INNER JOIN SalesLT.Customer AS c2
         ON c1.LastName = c2.LastName
        AND c1.CustomerID <> c2.CustomerID
OPTION (LOOP JOIN);

Includere il maggior contesto possibile selezionando la query dall'editor e includendo il sqlplan file nella finestra di chat di GitHub Copilot, come illustrato in questo screenshot.

Explain the execution plan for this query that performs a join with a filter on TotalDue:

SELECT c.CustomerID,
       c.FirstName,
       c.LastName,
       soh.SalesOrderID,
       soh.TotalDue
FROM SalesLT.Customer AS c
     INNER JOIN SalesLT.SalesOrderHeader AS soh
         ON c.CustomerID = soh.CustomerID
WHERE soh.TotalDue > 500;

Ristrutturazione delle query

La ristrutturazione delle query che usano espressioni di tabella comuni può migliorare la leggibilità e la gestibilità, soprattutto per la logica complessa o le sottoquery annidate. GitHub Copilot consente di riscrivere le query esistenti per usare le CTE mantenendo al tempo stesso la finalità e migliorando la chiarezza.

Esempio di selezione interna per CTE

Rewrite this query using common table expressions (CTEs) to improve clarity:

SELECT *
FROM (SELECT ProductID,
             SUM(Quantity) AS TotalQuantity
      FROM Sales
      GROUP BY ProductID) AS SubQuery;

Esempio di clausola HAVING in CTE

Rewrite the following query using a CTE (common table expression) to improve readability and maintainability:

SELECT soh.CustomerID,
       COUNT(*) AS OrderCount
FROM SalesLT.SalesOrderHeader AS soh
WHERE soh.OrderDate > '2022-01-01'
GROUP BY soh.CustomerID
HAVING COUNT(*) > 5;

Esempio di clausola di aggregazione in CTE

Use a CTE to separate the aggregation logic from the filter condition in this query:

SELECT ProductID,
       AVG(UnitPrice) AS AvgPrice
FROM SalesLT.SalesOrderDetail
GROUP BY ProductID
HAVING AVG(UnitPrice) > 50;

Scenari di prestazioni con approccio "code-first"

Quando si utilizzano ORM come Entity Framework, Prisma o Sequelize, le prestazioni possono peggiorare se le query non sono ottimizzate. GitHub Copilot consente di rilevare e risolvere problemi quali indici mancanti, filtri inefficienti e N+1 nei flussi di lavoro code-first.

Esempio di Prisma

In a Prisma project, how would you ensure that queries filtering by `OrderDate` in `SalesOrderHeader` are using indexes effectively?

Esempio di Entity Framework Core

Using Entity Framework Core, how can you analyze and optimize a LINQ query that retrieves the top 10 customers by total order value?

Esempio di Sequelize

In Sequelize, how do you restructure a query that fetches order history with product details to minimize N+1 query issues?

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.

Valutazione

Questa pagina ti è stata utile?

Last updated on 2025-11-19