Folosește GitHub Copilot în SQL Server Management Studio

20 minute

SQL Server Management Studio (SSMS) include GitHub Copilot, un asistent alimentat de AI care te ajută să scrii, să optimizezi și să depanezi codul T-SQL . GitHub Copilot oferă completări de cod în editorul de interogări atunci când scrii T-SQL și oferă, de asemenea, un chat unde poți folosi limbaj natural pentru a primi ajutor la redactarea interogărilor, a pune întrebări despre baza ta de date sau mediul tău și a primi ajutor cu probleme SQL. Ar trebui să folosești întotdeauna cea mai recentă versiune a SSMS (în prezent SSMS 22), deoarece aceasta este versiunea GA.

GitHub Copilot îți permite să selectezi un model, iar modelele disponibile variază în funcție de abonamentul tău. GitHub Copilot oferă completare a codului și folosește schema conexiunii și a bazei de date pentru a oferi context modelului și a îmbunătăți răspunsurile.

GitHub Copilot face dezvoltarea bazelor de date mai accesibilă și îmbunătățește productivitatea atât pentru dezvoltatorii noi, cât și pentru cei cu experiență. Fie că scrii interogări, depanezi probleme cu codul tău sau optimizezi performanța, GitHub Copilot te ajută să te concentrezi pe rezolvarea problemelor de business, nu pe reținerea sintaxei.

Înțelege GitHub Copilot în SQL Server Management Studio

GitHub Copilot în SSMS aduce completarea, generarea și chat-ul de cod alimentate de AI în fluxul tău de lucru pentru dezvoltarea bazei de date. GitHub Copilot te ajută să scrii T-SQL mai rapid, sugerând cod pe măsură ce tastezi, generând interogări întregi din comentarii în limbaj natural și oferind o experiență de chat unde poți pune întrebări despre baza ta de date și poți primi ajutor cu probleme SQL.

Explorează capabilitățile GitHub Copilot

GitHub Copilot oferă mai multe caracteristici pentru dezvoltarea SQL Server:

Completarea codului în linie: Sugestii în timp real pe măsură ce scrieți cod T-SQL
Limbaj natural pentru a codifica: Scrieți comentarii care vă descriu intenția, primiți întrebări funcționale
Sugestii pe mai multe linii: Generați blocuri întregi de interogare, proceduri sau funcții
Conștient de context: Înțelege schema bazei de date la care ești conectat

GitHub Copilot oferă, de asemenea, aceste funcții prin chat-ul său:

Sugestii conștiente de schemă: Cunoaște structurile exacte ale tabelelor, coloanele și tipurile de date
Optimizarea interogărilor: Analizează interogările și sugerează îmbunătățiri de performanță
Interogări în limbaj natural: Convertește întrebările în T-SQL în funcție de baza de date la care ești conectat
Explicați interogările: Descrie ce fac interogările existente într-un limbaj simplu
Remediați erorile: Oferă sugestii în funcție de context atunci când interogările eșuează
Recomandări pentru index: Sugerează indexuri bazate pe sugestiile de indici lipsă din DMV-uri sau într-un plan de interogare

GitHub Copilot oferă, de asemenea, asistență pentru depanarea interogărilor și performanței bazei de date, precum și răspunsuri la întrebări despre întreținerea bazelor de date, cele mai bune practici, configurarea bazelor de date și a serverelor și altele.

Activați GitHub Copilot în SSMS

Pentru a utiliza GitHub Copilot în SQL Server Management Studio:

Asigură-te că ai instalat SSMS 22
Instalează GitHub Copilot selectând sarcina de lucru AI Assistance în instalatorul Visual Studio
Conectați-vă cu contul GitHub care are un abonament GitHub Copilot activ
Configurează-ți preferințele în Opțiuni > Unelte > GitHub > Copilot și Opțiuni > Unelte > Editor > de Text Sugestii Inline

Notă

GitHub Copilot necesită un abonament (Individual, Business sau Enterprise). Unele organizații oferă GitHub Copilot pentru dezvoltatorii lor ca parte a licenței lor pentru instrumente de dezvoltare. Un abonament GitHub Copilot poate fi folosit și cu Visual Studio și VS Code.

Scrieți cod cu sugestii în linie

GitHub Copilot oferă sugestii pe măsură ce tastați:

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

Textul fantomă gri arată sugestiile GitHub Copilot. Apăsați Tab pentru a accepta sau Esc pentru a închide.

Generați proceduri și funcții stocate

Descrieți obiectele complexe ale bazei de date în comentarii:

-- 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 înțelege modelele procedurale și generează cod complet, executabil.

Explorați schema bazei de date

GitHub Copilot ajută la scrierea interogărilor pentru a explora structura bazei de date:

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

Aplică tiparele de codare ale editorului curent

GitHub Copilot urmează tiparele de codare din editorul tău actual. Dacă folosești convenții specifice de denumire, formatare sau tipare, GitHub Copilot le încorporează în sugestii:

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

Această consistență face ca sugestiile să pară mai naturale și reduce necesitatea formatării manuale.

Aplicați cele mai bune practici GitHub Copilot

Maximizați eficiența GitHub Copilot:

Obicei	Descriere
Scrieți comentarii descriptive	Comentariile clare și specifice produc sugestii de cod mai bune
Folosiți nume semnificative	Tabele descriptive și numele coloanelor ajută GitHub Copilot să înțeleagă contextul
Împărțiți sarcinile complexe	Scrieți mai multe comentarii pentru proceduri complexe, mai degrabă decât un bloc mare
Revizuiți toate sugestiile	Validați întotdeauna codul generat pentru corectitudine și securitate
Oferiți exemple	Includeți date eșantion sau rezultate așteptate în comentarii
Repetați sugestiile	Dacă prima sugestie nu este corectă, încearcă să-ți reformulezi comentariul

Interogare cu limbaj natural

Puneți întrebări despre datele dvs. folosind limba engleză simplă:

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

Pentru că GitHub Copilot se conectează la baza ta de date, generează cod care funcționează cu schema ta specifică.

Optimizați performanța interogărilor

GitHub Copilot analizează interogările și sugerează îmbunătățiri:

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

Înțelegeți și remediați erorile

Când interogările eșuează, GitHub Copilot explică problema și oferă soluții:

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

Profită la maximum de GitHub Copilot

Fereastra de chat GitHub Copilot funcționează fără o conexiune la baza de date, dar este mult mai valoroasă când ai un editor de interogări deschis și conectat la o bază de date. Folosește GitHub Copilot pentru dezvoltare generală T-SQL, completarea codului în editor, înțelegerea bazei de date și a serverului, optimizarea interogărilor și multe altele.

Dezvoltatorii pot folosi GitHub Copilot pentru programarea zilnică și pentru a răspunde la întrebări specifice bazei de date, ajutând la accelerarea dezvoltării bazelor de date, menținând în același timp calitatea codului și valorificând cele mai bune practici.

Feedback

Această pagină a fost utilă?