Démarrage rapide : Assistant Optimiseur de requête

GitHub Copilot aide les développeurs à optimiser les requêtes et à analyser les goulots d’étranglement des performances sans avoir besoin d’expertise en interne de base de données, en particulier les développeurs sans expertise approfondie en Transact-SQL (T-SQL). GitHub Copilot peut décomposer des requêtes SQL complexes, interpréter des plans d’exécution et suggérer des stratégies d’indexation ou des possibilités de refactorisation. Les développeurs peuvent maintenir leurs applications fonctionnelles et performantes tout en restant concentrés sur la livraison des fonctionnalités.

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.

Optimiser les performances avec GitHub Copilot

GitHub Copilot offre plusieurs façons d’aider les développeurs à écrire du code de base de données performant et prêt pour la production sans nécessiter d’expertise approfondie dans l’optimisation des requêtes ou l’analyse du plan d’exécution. Que vous ayez créé de nouvelles fonctionnalités ou examiné un problème de performances, GitHub Copilot peut exposer des insights, recommander des optimisations et aider à restructurer les requêtes, dans votre workflow existant dans Visual Studio Code.

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

Optimiser des requêtes

Utilisez GitHub Copilot pour identifier les inefficacités dans les requêtes ORM (Object-Relational Mapping) SQL et suggérer des moyens d’améliorer les performances. GitHub Copilot vous aide à appliquer les meilleures pratiques T-SQL et ORM, de la réécriture de requêtes lentes à des index recommandés ou à éviter des anti-modèles tels que les jointures Cartesian, en fonction de votre contexte actuel.

Exemple de base

Optimize the following query:

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

Exemple d’amélioration d’index

Suggest indexing improvements for this query:

SELECT ProductID
FROM SalesLT.SalesOrderDetail
WHERE Quantity > 100;

Exemple d’amélioration de jointure

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

SELECT * FROM Customers, Order;

Exemple de sélection imbriquée

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 du plan d’exécution

Les plans d’exécution fournissent une répartition détaillée de la façon dont le moteur SQL traite les requêtes. GitHub Copilot peut vous aider à interpréter les plans d’exécution, à identifier les goulots d’étranglement comme les jointures de boucle imbriquées et à suggérer des améliorations basées sur des modèles de requête réels et des stratégies d’indexation.

Vous pouvez utiliser la requête suivante comme exemple pour générer le plan d’exécution à l’aide de l’option Estimation/Réel du plan dans l’extension 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;

Incluez autant de contexte que possible, en sélectionnant la requête à partir de l’éditeur et en incluant le sqlplan fichier dans la fenêtre de conversation GitHub Copilot, comme illustré dans cette capture d’écran.

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.

Vous pouvez utiliser la requête suivante comme exemple pour générer le plan d’exécution à l’aide de l’option Estimation/Réel du plan dans l’extension 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);

Incluez autant de contexte que possible en sélectionnant la requête dans l’éditeur et en incluant le sqlplan fichier dans la fenêtre de conversation GitHub Copilot, comme illustré dans cette capture d’écran.

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;

Restructuration des requêtes

Les requêtes de restructuration utilisant des expressions de table courantes (CTEs) peuvent améliorer la lisibilité et la facilité de maintenance, en particulier pour les sous-requêtes complexes ou imbriquées. GitHub Copilot peut aider à réécrire vos requêtes existantes pour utiliser des CTEs tout en préservant l’intention et en améliorant la clarté.

Exemple de sélection interne vers 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;

Exemple de la clause HAVING dans une 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;

Exemple de clause d’agrégation en 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;

Scénarios de performances code-first

Lorsque vous travaillez avec des orms comme Entity Framework, Prisma ou Sequelize, les performances peuvent se dégrader si les requêtes ne sont pas optimisées. GitHub Copilot permet de détecter et de résoudre les problèmes tels que les index manquants, le filtrage inefficace et les problèmes N+1 dans les flux de travail code-first.

Exemple Prisma

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

Exemple de 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?

Exemple de Sequelize

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

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.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-11-19