Usar o GitHub Copilot no SQL Server Management Studio

20 minutos

O SSMS (SQL Server Management Studio) inclui o GitHub Copilot, um assistente baseado em IA que ajuda você a escrever, otimizar e solucionar problemas de código T-SQL. O GitHub Copilot fornece conclusões de código no editor de consultas ao escrever T-SQL e também fornece um chat em que você pode usar a linguagem natural para obter ajuda para escrever consultas, fazer perguntas sobre seu banco de dados ou ambiente e obter ajuda com problemas de SQL. Você sempre deve usar a versão mais recente do SSMS (atualmente SSMS 22), pois essa é a versão ga.

O GitHub Copilot permite que você selecione um modelo e os modelos disponíveis variam de acordo com sua assinatura. O GitHub Copilot oferece preenchimento de código e aproveita sua conexão e esquema de banco de dados para fornecer contexto ao modelo e melhorar as respostas.

O GitHub Copilot torna o desenvolvimento de banco de dados mais acessível e melhora a produtividade para desenvolvedores novos e experientes. Se você estiver escrevendo consultas, solucionando problemas com seu código ou otimizando o desempenho, o GitHub Copilot ajuda você a se concentrar na solução de problemas de negócios em vez de lembrar a sintaxe.

Entenda o GitHub Copilot no SQL Server Management Studio

O GitHub Copilot no SSMS traz preenchimento, geração e chat de código alimentados por IA para seu fluxo de trabalho de desenvolvimento de banco de dados. O GitHub Copilot ajuda você a escrever t-SQL mais rapidamente, sugerindo código à medida que digita, gerando consultas inteiras de comentários em linguagem natural e fornecendo uma experiência de chat em que você pode fazer perguntas sobre seu banco de dados e obter ajuda com problemas de SQL.

Explorar as funcionalidades do GitHub Copilot

O GitHub Copilot fornece vários recursos para o desenvolvimento do SQL Server:

Preenchimento de código embutido: Sugestões em tempo real ao escrever código T-SQL
Idioma natural para codificar: Escrever comentários descrevendo sua intenção, obter consultas de trabalho
Sugestões de várias linhas: Gerar blocos de consultas inteiros, procedimentos ou funções
Reconhecimento de contexto: Entende o esquema do banco de dados ao qual você está conectado

O GitHub Copilot também oferece esses recursos por meio de seu chat:

Sugestões com reconhecimento de esquema: Conhece as estruturas exatas da tabela, as colunas e os tipos de dados
Otimização de consulta: Analisa consultas e sugere melhorias de desempenho
Consultas de linguagem natural: Converte perguntas em T-SQL com base no banco de dados ao qual você está conectado
Explicar consultas: Descreve o que as consultas existentes fazem em linguagem simples
Corrigir erros: Fornece sugestões com reconhecimento de contexto quando as consultas falham
Recomendações de índice: Sugere índices com base nas sugestões de índice ausentes nas DMVs ou em um plano de consulta

O GitHub Copilot também fornece assistência para solucionar problemas de desempenho de consulta e banco de dados, além de responder a perguntas sobre manutenção de banco de dados, práticas recomendadas, configuração de banco de dados e servidor e muito mais.

** Habilitar o GitHub Copilot no SSMS

Para usar o GitHub Copilot no SQL Server Management Studio:

Verifique se você tem o SSMS 22 instalado
Instalar o GitHub Copilot selecionando a carga de trabalho de Assistência de IA no Instalador do Visual Studio
Entre com sua conta do GitHub que tenha uma assinatura ativa do GitHub Copilot
Configurar suas preferências em Ferramentas > Opções > GitHub > Copilot e Ferramentas > Opções > Editor de Texto > Sugestões Embutidas

Observação

O GitHub Copilot requer uma assinatura (Individual, Business ou Enterprise). Algumas organizações fornecem o GitHub Copilot para seus desenvolvedores como parte de sua licença de ferramentas de desenvolvimento. Uma assinatura do GitHub Copilot também pode ser usada com o Visual Studio e o VS Code.

Escrever código com sugestões embutidas

O GitHub Copilot fornece sugestões conforme você digita:

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

O texto fantasma cinza mostra as sugestões do GitHub Copilot. Pressione Tab para aceitar ou Esc para ignorar.

Gerar funções e procedimentos armazenados

Descreva objetos de banco de dados complexos nos comentários:

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

O GitHub Copilot entende os padrões de procedimento e gera um código completo e executável.

Explorar o esquema de banco de dados

O GitHub Copilot ajuda a escrever consultas para explorar sua estrutura de banco de dados:

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

Aplicar padrões de codificação do editor atual

O GitHub Copilot segue os padrões de codificação no seu editor atual. Se você usar convenções de nomenclatura, formatação ou padrões específicos, o GitHub Copilot as incorporará em sugestões:

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

Essa consistência faz com que as sugestões se sintam mais naturais e reduza a necessidade de formatação manual.

Aplicar as melhores práticas do GitHub Copilot

Maximizar a eficácia do GitHub Copilot:

Prática	Description
Escrever comentários descritivos	Comentários claros e específicos produzem melhores sugestões de código
Usar nomes significativos	Nomes de tabelas e colunas descritivos ajudam o GitHub Copilot a entender o contexto
Dividir tarefas complexas	Escrever vários comentários para procedimentos complexos em vez de um bloco grande
Examinar todas as sugestões	Sempre valide o código gerado para correção e segurança
Fornecer exemplos	Incluir dados de exemplo ou saída esperada em comentários
Iterar em sugestões	Se a primeira sugestão não estiver certa, tente reformular seu comentário

Consulta com linguagem natural

Faça perguntas sobre seus dados usando inglês simples:

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

Como o GitHub Copilot se conecta ao banco de dados, ele gera um código que funciona com seu esquema específico.

Otimizar o desempenho da consulta

O GitHub Copilot analisa consultas e sugere melhorias:

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

Entender e corrigir erros

Quando as consultas falham, o GitHub Copilot explica o problema e fornece correções:

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

Obter o máximo do GitHub Copilot

A janela de chat do GitHub Copilot funciona sem uma conexão de banco de dados, mas é muito mais valiosa quando você tem um editor de consultas aberto e conectado a um banco de dados. Use o GitHub Copilot para desenvolvimento geral do T-SQL, preenchimento de código no editor, compreensão do banco de dados e servidor, otimização de consulta e muito mais.

Os desenvolvedores podem usar o GitHub Copilot para codificação diária e responder a perguntas específicas do banco de dados, ajudando a acelerar o desenvolvimento do banco de dados, mantendo a qualidade do código e aproveitando as práticas recomendadas.

Comentários

Esta página foi útil?