GitHub Copilot gebruiken in SQL Server Management Studio

20 minuten

SQL Server Management Studio (SSMS) bevat GitHub Copilot, een AI-assistent die u helpt bij het schrijven, optimaliseren en oplossen van problemen met T-SQL-code . GitHub Copilot biedt codevoltooiingen in de queryeditor bij het schrijven van T-SQL en biedt ook een chat waar u natuurlijke taal kunt gebruiken om hulp te krijgen bij het schrijven van query's, vragen te stellen over uw database of omgeving en hulp te krijgen bij SQL-problemen. U moet altijd de nieuwste versie van SSMS (momenteel SSMS 22) gebruiken, omdat dit de GA-release is.

Met GitHub Copilot kunt u een model selecteren en de beschikbare modellen variëren op basis van uw abonnement. GitHub Copilot biedt het voltooien van code en maakt gebruik van uw verbindings- en databaseschema om context te bieden aan het model en reacties te verbeteren.

GitHub Copilot maakt databaseontwikkeling toegankelijker en verbetert de productiviteit voor zowel nieuwe als ervaren ontwikkelaars. Of u nu query's schrijft, problemen met uw code oplost of prestaties optimaliseert, GitHub Copilot helpt u zich te concentreren op het oplossen van zakelijke problemen in plaats van de syntaxis te onthouden.

Begrijp GitHub Copilot in SQL Server Management Studio

GitHub Copilot in SSMS brengt door AI ondersteunde codeaanvulling, codegeneratie en chat naar uw workflow voor databaseontwikkeling. GitHub Copilot helpt u sneller T-SQL te schrijven door code voor te stellen terwijl u typt, volledige query's te genereren op basis van opmerkingen in natuurlijke taal en een chat-ervaring te bieden waar u vragen over uw database kunt stellen en hulp kunt krijgen bij SQL-problemen.

Mogelijkheden van GitHub Copilot verkennen

GitHub Copilot biedt verschillende functies voor sql Server-ontwikkeling:

Voltooiing van inlinecode: Realtime suggesties tijdens het schrijven van T-SQL-code
Natuurlijke taal voor code: Opmerkingen schrijven waarin uw intentie wordt beschreven, werkquery's krijgen
Suggesties voor meerdere regels: Volledige queryblokken, procedures of functies genereren
Contextbewust: Begrijpt het schema van de database waarmee u bent verbonden

GitHub Copilot biedt ook deze functies via de chat:

Schemabewuste suggesties: Kent uw exacte tabelstructuren, kolommen en gegevenstypen
Queryoptimalisatie: Analyseert query's en stelt prestatieverbeteringen voor
Query's in natuurlijke taal: Converteert vragen naar T-SQL op basis van de database waarmee u bent verbonden
Query's uitleggen: Beschrijft wat bestaande query's doen in gewone taal
Fouten oplossen: Biedt contextbewuste suggesties wanneer query's mislukken
Aanbevelingen voor index: Suggereren indexen op basis van ontbrekende indexsuggesties in de DMVs of in een queryplan.

GitHub Copilot biedt ook hulp bij het oplossen van problemen met query- en databaseprestaties, samen met het beantwoorden van vragen over databaseonderhoud, best practices, database- en serverconfiguratie en meer.

GitHub Copilot inschakelen in SSMS

GitHub Copilot gebruiken in SQL Server Management Studio:

Zorg ervoor dat SSMS 22 is geïnstalleerd
Installeer GitHub Copilot door de workload AI-hulp te selecteren in het Visual Studio-installatieprogramma
Meld u aan met uw GitHub-account met een actief GitHub Copilot-abonnement
Uw voorkeuren configureren in Extra > Opties > GitHub > Copilot en Extra > Opties > Teksteditor > Inline Suggesties

Opmerking

GitHub Copilot vereist een abonnement (Individueel, Zakelijk of Enterprise). Sommige organisaties bieden GitHub Copilot voor hun ontwikkelaars als onderdeel van hun licentie voor ontwikkelhulpprogramma's. Een GitHub Copilot-abonnement kan ook worden gebruikt met Visual Studio en VS Code.

Code schrijven met inlinesuggesties

GitHub Copilot biedt suggesties terwijl u typt:

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

In de grijze spooktekst ziet u de suggesties van GitHub Copilot. Druk op Tab om te accepteren of op Esc om te negeren.

Opgeslagen procedures en functies genereren

Complexe databaseobjecten in opmerkingen beschrijven:

-- 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 begrijpt procedurepatronen en genereert volledige uitvoerbare code.

Databaseschema verkennen

GitHub Copilot helpt bij het schrijven van query's om uw databasestructuur te verkennen:

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

Coderingspatronen van de huidige editor toepassen

GitHub Copilot volgt de coderingspatronen in uw huidige editor. Als u specifieke naamconventies, opmaak of patronen gebruikt, worden deze opgenomen in suggesties in GitHub Copilot:

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

Deze consistentie maakt suggesties natuurlijker en vermindert de noodzaak van handmatige opmaak.

GitHub Copilot best practices toepassen

Maximaliseer de effectiviteit van GitHub Copilot:

Practice	Description
Beschrijvende opmerkingen schrijven	Duidelijke, specifieke opmerkingen produceren betere codesuggesties
Betekenisvolle namen gebruiken	Beschrijvende tabel- en kolomnamen helpen GitHub Copilot context te begrijpen
Het opsplitsen van complexe taken	Meerdere opmerkingen schrijven voor complexe procedures in plaats van één groot blok
Alle suggesties bekijken	Gegenereerde code altijd valideren voor juistheid en beveiliging
Voorbeelden opgeven	Voorbeeldgegevens of verwachte uitvoer opnemen in opmerkingen
Itereren op suggesties	Als de eerste suggestie niet juist is, probeert u de opmerking opnieuw te formuleren

Query's uitvoeren met natuurlijke taal

Stel vragen over uw gegevens met behulp van gewoon Engels:

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

Omdat GitHub Copilot verbinding maakt met uw database, wordt er code gegenereerd die werkt met uw specifieke schema.

Queryprestaties optimaliseren

GitHub Copilot analyseert query's en stelt verbeteringen voor:

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

Fouten begrijpen en oplossen

Wanneer query's mislukken, legt GitHub Copilot het probleem uit en biedt oplossingen:

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

Optimaal profiteren van GitHub Copilot

Het GitHub Copilot-chatvenster werkt zonder een databaseverbinding, maar het is veel waardevoller wanneer u een queryeditor hebt geopend en verbonden met een database. Gebruik GitHub Copilot voor algemene T-SQL-ontwikkeling, codevoltooiing in de editor, inzicht in uw database en server, queryoptimalisatie en meer.

Ontwikkelaars kunnen GitHub Copilot gebruiken voor dagelijkse codering en om specifieke databasevragen te beantwoorden, waardoor databaseontwikkeling wordt versneld terwijl codekwaliteit wordt gehandhaafd en aanbevolen procedures worden gebruikt.

Feedback

Is deze pagina nuttig?