Snelstartgids: Query optimizer assistant

GitHub Copilot helpt ontwikkelaars bij het optimaliseren van query's en het analyseren van prestatieknelpunten zonder expertise op het gebied van interne databases, met name ontwikkelaars zonder diepgaande kennis van Transact-SQL (T-SQL). GitHub Copilot kan complexe SQL opsplitsen, uitvoeringsplannen interpreteren en indexeringsstrategieën voorstellen of mogelijkheden voor herstructurering identificeren. Ontwikkelaars kunnen hun apps functioneel en presterend houden, terwijl ze gefocust blijven op functielevering.

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.

Prestaties optimaliseren met GitHub Copilot

GitHub Copilot biedt meerdere manieren om ontwikkelaars te helpen bij het schrijven van performante, productieklare databasecode zonder dat hiervoor diepgaande expertise nodig is bij het afstemmen van query's of het uitvoeren van een plananalyse. Of u nu nieuwe functies bouwt of een prestatieprobleem onderzoekt, GitHub Copilot kan inzichten opleveren, optimalisaties aanbevelen en query's helpen herstructureren, allemaal binnen uw bestaande werkstroom in Visual Studio Code.

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

Query's optimaliseren

Gebruik GitHub Copilot om inefficiënties in SQL- of object-relationele mapping (ORM) query's te identificeren en manieren te suggereren om de prestaties te verbeteren. GitHub Copilot helpt u om best practices voor T-SQL en ORM toe te passen, van het herschrijven van trage query's tot het aanbevelen van indexen of het voorkomen van antipatronen, zoals Cartesische joins, op basis van uw huidige context.

Basisvoorbeeld

Optimize the following query:

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

Voorbeeld van indexverbetering

Suggest indexing improvements for this query:

SELECT ProductID
FROM SalesLT.SalesOrderDetail
WHERE Quantity > 100;

Voorbeeld van samenvoegingsverbetering

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

SELECT * FROM Customers, Order;

Voorbeeld van geneste selectie

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

Analyse van uitvoeringsplan

Uitvoeringsplannen bieden een gedetailleerde uitsplitsing van hoe de SQL Engine query's verwerkt. GitHub Copilot kan u helpen bij het interpreteren van uitvoeringsplannen, het identificeren van knelpunten zoals geneste luskoppelingen en het voorstellen van verbeteringen op basis van echte querypatronen en indexeringsstrategieën.

U kunt de volgende query als voorbeeld gebruiken om het uitvoeringsplan te genereren met behulp van de optie Geschat/werkelijk plan in de MSSQL-extensie:

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;

Neem zoveel mogelijk context op door de query te selecteren in de editor en het sqlplan bestand op te nemen in het GitHub Copilot-chatvenster, zoals wordt weergegeven in deze schermopname.

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.

U kunt de volgende query als voorbeeld gebruiken om het uitvoeringsplan te genereren met behulp van de optie Geschat/werkelijk plan in de MSSQL-extensie:

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

Neem zoveel mogelijk context op door de query te selecteren in de editor en het sqlplan bestand op te nemen in het GitHub Copilot-chatvenster, zoals wordt weergegeven in deze schermopname.

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;

Herstructurering van queries

Het herstructureren van query's met behulp van common table expressions (CTE's) kan de leesbaarheid en onderhoudbaarheid verbeteren, met name voor complexe logica of geneste subquery's. GitHub Copilot kan u helpen bij het herschrijven van uw bestaande query's voor het gebruik van CTE's en het behouden van intenties en het verbeteren van de duidelijkheid.

Voorbeeld van een inner select naar een 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;

HAVING-component voor CTE-voorbeeld

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;

Aggregatiecomponent naar CTE-voorbeeld

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;

Code-first prestatiescenario's

Wanneer u werkt met ORM's zoals Entity Framework, Prisma of Sequelize, kunnen de prestaties afnemen als query's niet zijn geoptimaliseerd. GitHub Copilot helpt bij het detecteren en oplossen van problemen zoals ontbrekende indexen, inefficiënt filteren en N+1-problemen in code-first-werkstromen.

Prisma-voorbeeld

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

Voorbeeld van 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?

Voorbeeld van Sequelize

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

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. Schermafbeeldingen 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.

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-19