Verwenden von Copilot in SQL Server Management Studio

20 Minuten

SQL Server Management Studio (SSMS) unterstützt zwei KI-gestützte Codierungsassistenten, die Ihnen beim Schreiben, Optimieren und Behandeln von T-SQL-Code helfen. GitHub Copilot bietet allgemeine Programmierunterstützung in mehreren Sprachen, während Copilot datenbankbezogene Vorschläge für Ihre verbundene SQL Server-Instanz bietet.

Beide Tools verwenden große Sprachmodelle, um die Datenbankentwicklung zu beschleunigen. GitHub Copilot glänzt bei der Codevervollständigung und Mustererkennung in Ihrem gesamten Codebestand, während Copilot Ihr Datenbankschema, Ihre Indizes und Statistiken nutzt, um kontextbezogene T-SQL-Unterstützung zu bieten.

Diese KI-Assistenten machen die Datenbankentwicklung barrierefreier und verbessern die Produktivität sowohl für neue als auch erfahrene Entwickler. Ganz gleich, ob Sie Abfragen schreiben, Code debuggen oder die Leistung optimieren, KI-gestützte Unterstützung hilft Ihnen dabei, sich auf die Lösung von Geschäftsproblemen zu konzentrieren, anstatt sich an die Syntax zu erinnern.

Verwenden von GitHub Copilot in SSMS

GitHub Copilot in SSMS bringt KI-gestützte Codevervollständigung und -generierung in Ihren Datenbankentwicklungsworkflow. Als allgemeiner Codierungsassistent hilft GitHub Copilot Ihnen, T-SQL schneller zu schreiben, indem Sie Code während der Eingabe vorschlagen und ganze Abfragen aus Kommentaren in natürlicher Sprache generieren.

Grundlegendes zu GitHub Copilot-Funktionen

GitHub Copilot bietet mehrere Features für die SQL Server-Entwicklung:

Abschluss des Inlinecodes: Echtzeitvorschläge beim Schreiben von T-SQL-Code
Natürliche Sprache für Code: Schreiben von Kommentaren, die Ihre Absicht beschreiben, Arbeitsabfragen abrufen
Mehrzeilige Vorschläge: Generieren vollständiger Abfrageblöcke, Prozeduren oder Funktionen
Mustererkennung: Lernen Sie aus Ihrem Codierungsstil und allgemeinen Mustern in Ihrem Arbeitsbereich
Kontextfähig: Berücksichtigt den Code, den Sie bereits in der aktuellen Datei geschrieben haben.
Unterstützung für mehrere Sprachen: Funktioniert mit T-SQL, PowerShell, Python und anderen Sprachen, die in Datenbankprojekten verwendet werden

GitHub Copilot analysiert Ihre aktuelle Datei, geöffnete Registerkarten und Arbeitsbereiche, um relevante Vorschläge bereitzustellen. Sie stellt zwar keine direkte Verbindung mit Ihrer Datenbank her, erkennt jedoch T-SQL-Syntaxmuster und gängige Methoden für die Datenbankentwicklung.

Aktivieren von GitHub Copilot in SSMS

So verwenden Sie GitHub Copilot in SQL Server Management Studio:

Stellen Sie sicher, dass SSMS 19.3 oder höher installiert ist
Installieren der GitHub Copilot-Erweiterung über das Menü "Erweiterungen"
Melden Sie sich mit Ihrem GitHub-Konto an, das über ein aktives GitHub Copilot-Abonnement verfügt
Konfigurieren Ihrer Einstellungen in Tools > Options > GitHub Copilot

Hinweis

GitHub Copilot erfordert ein kostenpflichtiges Abonnement (Individual, Business oder Enterprise). Einige Organisationen stellen GitHub Copilot für ihre Entwickler als Teil ihrer Entwicklungstools-Lizenz bereit.

Code schreiben mit Inlinevorschlägen

GitHub Copilot bietet Vorschläge während der Eingabe:

-- Start typing a query
SELECT c.CustomerName, 
-- 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

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

Der graue Geistertext zeigt die Vorschläge von Copilot. Drücken Sie Tab, um zu akzeptieren, oder Esc, um abzulehnen.

Generieren gespeicherter Prozeduren und Funktionen

Beschreiben komplexer Datenbankobjekte in Kommentaren:

-- 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 versteht prozedurale Muster und generiert vollständigen ausführbaren Code.

Erkunden des Datenbankschemas

GitHub Copilot hilft beim Schreiben von Abfragen, um Ihre Datenbankstruktur zu erkunden:

-- Show all foreign key relationships for Orders table

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

Lernen Sie aus Ihren Codierungsmustern

GitHub Copilot passt sich im Laufe der Zeit an Ihren Stil an. Wenn Sie konsequent bestimmte Benennungskonventionen, Formatierungen oder Muster verwenden, integriert Copilot sie in Vorschläge:

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

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

Diese Personalisierung macht Vorschläge natürlicher und reduziert den Bedarf an manueller Formatierung.

Anwenden bewährter Methoden für GitHub Copilot

Maximieren Sie die Effektivität von GitHub Copilot:

Praxis	Description
Beschreibende Kommentare schreiben	Klare, bestimmte Kommentare erzeugen bessere Codevorschläge
Verwenden aussagekräftiger Namen	Beschreibende Tabellen- und Spaltennamen helfen Copilot, den Kontext zu verstehen
Aufschlüsseln komplexer Aufgaben	Schreibt mehrere Kommentare für komplexe Verfahren anstelle eines großen Blocks
Alle Vorschläge überprüfen	Immer generierten Code auf Richtigkeit und Sicherheit überprüfen
Beispiele bereitstellen	Beispieldaten oder erwartete Ausgabe in Kommentare einschließen
Kontext in der Nähe beibehalten	Öffnen verwandter Dateien oder Schemas, um Copilot mehr Kontext zu verleihen
Überarbeiten von Vorschlägen	Wenn der erste Vorschlag nicht ganz richtig ist, versuchen Sie, Ihren Kommentar neu zu erstellen.

Verwenden von Copilot in SSMS

Copilot in SSMS bietet datenbankbasierte KI-Unterstützung, die eine direkte Verbindung mit Ihrer SQL Server-Instanz herstellt. Im Gegensatz zu GitHub Copilot hat Copilot Zugriff auf Ihr Datenbankschema, Indizes, Statistiken und Metadaten, wodurch kontextbezogenere T-SQL-Vorschläge ermöglicht werden.

Grundlegendes zu Copilot-Funktionen

Copilot bietet datenbankspezifische Features:

Schemabezogene Vorschläge: Kennt Ihre genauen Tabellenstrukturen, Spalten und Datentypen
Abfrageoptimierung: Analysiert Ausführungspläne und schlägt Leistungsverbesserungen vor
Abfragen natürlicher Sprachen: Wandelt Fragen basierend auf Ihrer tatsächlichen Datenbank in T-SQL um.
Erläutern von Abfragen: Beschreibt, was vorhandene Abfragen in Nur-Sprache tun
Beheben von Fehlern: Stellt kontextbezogene Vorschläge bereit, wenn Abfragen fehlschlagen
Indexempfehlungen: Schlägt Indizes basierend auf Ihren Datenbankstatistiken vor

Da Copilot eine Verbindung mit Ihrer Datenbank herstellt, wird Code generiert, der ohne Änderung mit Ihrem spezifischen Schema funktioniert.

Abfrage mit natürlicher Sprache

Stellen Sie Fragen zu Ihren Daten mit einfachem Englisch:

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

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

Copilot kennt Ihre genauen Tabellen- und Spaltennamen und stellt sicher, dass die Abfrage sofort funktioniert.

Optimieren der Abfrageleistung

Copilot analysiert Abfragen und schlägt Verbesserungen vor:

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

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

Verstehen und Beheben von Fehlern

Wenn Abfragen fehlschlagen, erläutert Copilot das Problem und stellt Korrekturen bereit:

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

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

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

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

Auswählen des richtigen Tools

Beide Tools bieten Wert für die SQL Server-Entwicklung:

Merkmal	GitHub Copilot	Copilot
Datenbankschema-Sensibilisierung	Nein	Yes
Unterstützung mehrerer Sprachen	Yes	T-SQL-Fokus
Abfrageoptimierung	Musterbasiert	Datenbankspezifisch
Funktioniert außerhalb von SSMS	Yes	Nein
Erfordert Datenbankverbindung	Nein	Yes
Subscription	GitHub Copilot	Copilot

Verwenden Sie GitHub Copilot für allgemeine T-SQL-Entwicklung, multisprachige Projekte und Codeabschluss in der gesamten Codebasis. Verwenden Sie Copilot für datenbankspezifische Aufgaben, bei denen schemabezogene Sensibilisierung, Abfrageoptimierung und direkte Datenbankinteraktion bessere Ergebnisse liefern.

Viele Entwickler verwenden beides: GitHub Copilot für den täglichen Code und Copilot beim Arbeiten mit bestimmten Datenbankinstanzen. Gemeinsam beschleunigen diese KI-Assistenten die Datenbankentwicklung, während Codequalität und Sicherheitsstandards beibehalten werden.

Feedback

War diese Seite hilfreich?