Utiliser GitHub Copilot dans SQL Server Management Studio

20 minutes

SQL Server Management Studio (SSMS) comprend GitHub Copilot, un assistant basé sur l’IA qui vous aide à écrire, optimiser et dépanner du code T-SQL . GitHub Copilot fournit des saisies semi-automatiques de code dans l’éditeur de requête lors de l’écriture de T-SQL et fournit également une conversation dans laquelle vous pouvez utiliser le langage naturel pour obtenir de l’aide pour écrire des requêtes, poser des questions sur votre base de données ou votre environnement et obtenir de l’aide sur les problèmes SQL. Vous devez toujours utiliser la dernière version de SSMS (actuellement SSMS 22) car il s’agit de la version en disponibilité générale.

GitHub Copilot vous permet de sélectionner un modèle et les modèles disponibles varient en fonction de votre abonnement. GitHub Copilot offre la saisie semi-automatique du code et tire parti de votre schéma de connexion et de base de données pour fournir un contexte au modèle et améliorer les réponses.

GitHub Copilot rend le développement de base de données plus accessible et améliore la productivité pour les développeurs nouveaux et expérimentés. Que vous écriviez des requêtes, résolvez des problèmes avec votre code ou optimisez les performances, GitHub Copilot vous aide à vous concentrer sur la résolution des problèmes métier plutôt que sur la mémorisation de la syntaxe.

Comprendre GitHub Copilot dans SQL Server Management Studio

GitHub Copilot dans SSMS apporte la saisie semi-automatique du code, la génération et la conversation à votre flux de travail de développement de base de données. GitHub Copilot vous aide à écrire T-SQL plus rapidement en suggérant du code à mesure que vous tapez, en générant des requêtes entières à partir de commentaires en langage naturel et en fournissant une expérience de conversation où vous pouvez poser des questions sur votre base de données et obtenir de l’aide sur les problèmes SQL.

Explorer les fonctionnalités de GitHub Copilot

GitHub Copilot fournit plusieurs fonctionnalités pour le développement SQL Server :

Complétion de code en ligne : Suggestions en temps réel lors de la rédaction du code T-SQL
Langage naturel à coder : Écrire des commentaires décrivant votre intention, obtenir des requêtes de travail
Suggestions multilignes : Générer des blocs de requête, des procédures ou des fonctions entiers
Prise en compte du contexte : Comprend le schéma de la base de données à laquelle vous êtes connecté

GitHub Copilot propose également ces fonctionnalités via sa conversation :

Suggestions prenant en compte les schémas : Connaît vos structures, colonnes et types de données exactes de table
Optimisation des requêtes : Analyse les requêtes et suggère des améliorations des performances
Requêtes en langage naturel : Convertit les questions en T-SQL en fonction de la base de données à laquelle vous êtes connecté
Expliquer les requêtes : Décrit ce que font les requêtes existantes en langage brut
Corrigez les erreurs : Fournit des suggestions contextuelles lorsque les requêtes échouent
Recommandations d’index : Suggère des index en fonction des suggestions d’index manquantes dans les DMV ou dans un plan de requête

GitHub Copilot fournit également de l’aide pour résoudre les problèmes de performances des requêtes et des bases de données, ainsi que répondre à des questions sur la maintenance de la base de données, les meilleures pratiques, la configuration de la base de données et du serveur, etc.

Activer GitHub Copilot dans SSMS

Pour utiliser GitHub Copilot dans SQL Server Management Studio :

Vérifiez que SSMS 22 est installé
Installer GitHub Copilot en sélectionnant la charge de travail d’assistance IA dans Visual Studio Installer
Connectez-vous avec votre compte GitHub disposant d’un abonnement GitHub Copilot actif
Configurez vos préférences dans Outils > Options > GitHub > Copilot et Outils > Options > Éditeur de texte > Suggestions en ligne

Note

GitHub Copilot nécessite un abonnement (individuel, professionnel ou entreprise). Certaines organisations fournissent GitHub Copilot pour leurs développeurs dans le cadre de leur licence d’outils de développement. Un abonnement GitHub Copilot peut également être utilisé avec Visual Studio et VS Code.

Écrire du code avec des suggestions inline

GitHub Copilot fournit des suggestions à mesure que vous tapez :

-- Start typing a query
SELECT c.CustomerName, 
-- GitHub Copilot suggests: c.Email, c.Phone, c.City
-- Press Tab to accept

-- Or write a comment describing what you need:
-- Get total sales by product category for last quarter

-- GitHub Copilot generates:
SELECT 
    p.Category,
    SUM(od.Quantity * od.UnitPrice) AS TotalSales
FROM Products p
INNER JOIN OrderDetails od ON p.ProductID = od.ProductID
INNER JOIN Orders o ON od.OrderID = o.OrderID
WHERE o.OrderDate >= DATEADD(QUARTER, -1, GETDATE())
GROUP BY p.Category
ORDER BY TotalSales DESC;

Le texte fantôme gris affiche les suggestions de GitHub Copilot. Appuyez sur Tab pour accepter ou échap pour ignorer.

Générer des procédures stockées et des fonctions

Décrire les objets de base de données complexes dans les commentaires :

-- Create a stored procedure to calculate customer lifetime value
-- Parameters: @CustomerID int
-- Returns: @TotalValue money, @OrderCount int, @FirstOrderDate date, @LastOrderDate date

-- GitHub Copilot generates:
CREATE PROCEDURE sp_GetCustomerLifetimeValue
    @CustomerID INT
AS
BEGIN
    SELECT 
        @CustomerID AS CustomerID,
        SUM(od.Quantity * od.UnitPrice) AS TotalValue,
        COUNT(DISTINCT o.OrderID) AS OrderCount,
        MIN(o.OrderDate) AS FirstOrderDate,
        MAX(o.OrderDate) AS LastOrderDate
    FROM Orders o
    INNER JOIN OrderDetails od ON o.OrderID = od.OrderID
    WHERE o.CustomerID = @CustomerID
    GROUP BY o.CustomerID;
END;

GitHub Copilot comprend les modèles procéduraux et génère du code exécutable complet.

Explorer le schéma de base de données

GitHub Copilot permet d’écrire des requêtes pour explorer votre structure de base de données :

-- Show all foreign key relationships for Orders table

-- GitHub Copilot suggests:
SELECT 
    fk.name AS ForeignKeyName,
    OBJECT_NAME(fk.parent_object_id) AS TableName,
    COL_NAME(fkc.parent_object_id, fkc.parent_column_id) AS ColumnName,
    OBJECT_NAME(fk.referenced_object_id) AS ReferencedTable,
    COL_NAME(fkc.referenced_object_id, fkc.referenced_column_id) AS ReferencedColumn
FROM sys.foreign_keys fk
INNER JOIN sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id
WHERE OBJECT_NAME(fk.parent_object_id) = 'Orders'
   OR OBJECT_NAME(fk.referenced_object_id) = 'Orders';

Appliquer des modèles de codage de l’éditeur actuel

GitHub Copilot suit les modèles de codage dans votre éditeur actuel. Si vous utilisez des conventions d’affectation de noms spécifiques, une mise en forme ou des modèles, GitHub Copilot les incorpore dans des suggestions :

-- If you typically write your queries like this:
SELECT 
    c.CustomerID
    ,c.CustomerName
    ,c.Email
FROM Customers AS c
WHERE c.IsActive = 1;

-- GitHub Copilot follows your style and suggests:
SELECT 
    o.OrderID
    ,o.OrderDate
    ,o.TotalAmount
FROM Orders AS o
WHERE o.Status = 'Completed';

Cette cohérence rend les suggestions plus naturelles et réduit la nécessité d’une mise en forme manuelle.

Appliquer les meilleures pratiques GitHub Copilot

Optimisez l’efficacité de GitHub Copilot :

Pratique	Descriptif
Écrire des commentaires descriptifs	Des commentaires clairs et spécifiques produisent de meilleures suggestions de code
Utiliser des noms explicites	Les noms de tables et de colonnes descriptifs aident GitHub Copilot à comprendre le contexte
Décomposer les tâches complexes	Écrire plusieurs commentaires pour des procédures complexes plutôt qu’un bloc volumineux
Passer en revue toutes les suggestions	Toujours valider le code généré pour l’exactitude et la sécurité
Fournir des exemples	Inclure des exemples de données ou une sortie attendue dans les commentaires
Itérer sur les suggestions	Si la première suggestion n’est pas appropriée, essayez de rééduler votre commentaire

Effectuer des requêtes en langage naturel

Posez des questions sur vos données à l’aide de l’anglais brut :

-- Ask GitHub Copilot: "Show customers who placed more than 5 orders last month"

-- GitHub Copilot generates (using your actual schema):
SELECT 
    c.CustomerID,
    c.CustomerName,
    c.Email,
    COUNT(o.OrderID) AS OrderCount
FROM Customers c
INNER JOIN Orders o ON c.CustomerID = o.CustomerID
WHERE o.OrderDate >= DATEADD(MONTH, -1, GETDATE())
    AND o.OrderDate < DATEADD(DAY, 1, EOMONTH(DATEADD(MONTH, -1, GETDATE())))
GROUP BY c.CustomerID, c.CustomerName, c.Email
HAVING COUNT(o.OrderID) > 5
ORDER BY OrderCount DESC;

Étant donné que GitHub Copilot se connecte à votre base de données, il génère du code qui fonctionne avec votre schéma spécifique.

Optimiser les performances des requêtes

GitHub Copilot analyse les requêtes et suggère des améliorations :

-- Select a slow query and ask: "How can I make this faster?"

-- Original query:
SELECT c.CustomerName, SUM(od.Quantity * od.UnitPrice) AS Total
FROM Customers c
LEFT JOIN Orders o ON c.CustomerID = o.CustomerID
LEFT JOIN OrderDetails od ON o.OrderID = od.OrderID
WHERE o.OrderDate >= '2024-01-01'
GROUP BY c.CustomerName;

-- GitHub Copilot suggests:
-- 1. Change LEFT JOIN to INNER JOIN (WHERE filters out NULLs anyway)
-- 2. Add covering index: CREATE INDEX IX_Orders_Date ON Orders(OrderDate, CustomerID, OrderID)
-- 3. Consider indexed view for frequent aggregations

-- Optimized query:
SELECT c.CustomerName, SUM(od.Quantity * od.UnitPrice) AS Total
FROM Customers c
INNER JOIN Orders o ON c.CustomerID = o.CustomerID
INNER JOIN OrderDetails od ON o.OrderID = od.OrderID
WHERE o.OrderDate >= '2024-01-01'
GROUP BY c.CustomerName
OPTION (RECOMPILE);

Comprendre et corriger les erreurs

Lorsque les requêtes échouent, GitHub Copilot explique le problème et fournit des correctifs :

-- Query with error:
SELECT CustomerName, SUM(TotalAmount)
FROM Orders;

-- Error: Column 'Orders.CustomerName' is invalid in the select list

-- Ask GitHub Copilot: "What's wrong with this query?"

-- GitHub Copilot explains and fixes:
/*
The error occurs because CustomerName is not in an aggregate function or GROUP BY clause.
When using aggregate functions like SUM(), all non-aggregated columns must be grouped.
*/

-- Corrected query:
SELECT CustomerName, SUM(TotalAmount) AS Total
FROM Orders
GROUP BY CustomerName;

Tirer le meilleur parti de GitHub Copilot

La fenêtre de conversation GitHub Copilot fonctionne sans connexion de base de données, mais elle est beaucoup plus utile lorsque vous avez un éditeur de requête ouvert et connecté à une base de données. Utilisez GitHub Copilot pour le développement T-SQL général, la saisie semi-automatique du code dans l’éditeur, la compréhension de votre base de données et de votre serveur, l’optimisation des requêtes, etc.

Les développeurs peuvent utiliser GitHub Copilot pour le codage quotidien et répondre à des questions de base de données spécifiques, ce qui permet d’accélérer le développement de bases de données tout en conservant la qualité du code et en tirant parti des meilleures pratiques.

Commentaires

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