Uso de GitHub Copilot en SQL Server Management Studio

20 minutos

SQL Server Management Studio (SSMS) incluye GitHub Copilot, un asistente con tecnología de IA que le ayuda a escribir, optimizar y solucionar problemas de código T-SQL . GitHub Copilot proporciona finalizaciones de código en el editor de consultas al escribir T-SQL y también proporciona un chat donde puede usar lenguaje natural para obtener ayuda para escribir consultas, formular preguntas sobre la base de datos o el entorno y obtener ayuda con problemas de SQL. Siempre debe usar la versión más reciente de SSMS (actualmente SSMS 22), ya que es la versión de disponibilidad general.

GitHub Copilot permite seleccionar un modelo y los modelos disponibles varían en función de su suscripción. GitHub Copilot ofrece finalización de código y aprovecha el esquema de conexión y base de datos para proporcionar contexto al modelo y mejorar las respuestas.

GitHub Copilot hace que el desarrollo de bases de datos sea más accesible y mejora la productividad de los desarrolladores nuevos y experimentados. Si está escribiendo consultas, solucionando problemas con su código u optimizando el rendimiento, GitHub Copilot le permite enfocarse en resolver problemas empresariales en lugar de recordar la sintaxis.

Entender GitHub Copilot en SQL Server Management Studio

GitHub Copilot en SSMS ofrece finalización de código, generación y chat impulsados por IA al flujo de trabajo del desarrollo de bases de datos. GitHub Copilot le ayuda a escribir T-SQL más rápido al sugerir código a medida que escribe, generar consultas completas a partir de comentarios de lenguaje natural y proporcionar una experiencia de chat donde puede hacer preguntas sobre la base de datos y obtener ayuda con problemas de SQL.

Exploración de las funcionalidades de Copilot de GitHub

GitHub Copilot proporciona varias características para el desarrollo de SQL Server:

Finalización de código insertado: sugerencias en tiempo real al escribir código T-SQL
Lenguaje natural a código: Escribir comentarios que describan la intención, obtener consultas funcionales
Sugerencias de varias líneas: Generar bloques de consulta completos, procedimientos o funciones
Reconocimiento del contexto: Comprende el esquema de la base de datos a la que está conectado.

GitHub Copilot también ofrece estas características a través de su chat:

Sugerencias compatibles con el esquema: Conoce las estructuras, columnas y tipos de datos exactos de la tabla
Optimización de consultas: Analiza las consultas y sugiere mejoras de rendimiento.
Consultas de lenguaje natural: Convierte preguntas en T-SQL en función de la base de datos a la que está conectado.
Explicar las consultas: Describe lo que hacen las consultas existentes en lenguaje sin formato
Corrección de errores: Proporciona sugerencias contextuales cuando se produce un error en las consultas
Recomendaciones de índice: Sugiere índices basados en las sugerencias de índice que faltan en las DMV o en un plan de consulta.

GitHub Copilot también proporciona ayuda para solucionar problemas de rendimiento de consultas y bases de datos, además de responder a preguntas sobre el mantenimiento de bases de datos, procedimientos recomendados, configuración de bases de datos y servidor, etc.

Habilitación de GitHub Copilot en SSMS

Para usar GitHub Copilot en SQL Server Management Studio:

Asegúrese de que tiene instalado SSMS 22
Instale GitHub Copilot seleccionando la carga de trabajo asistencia de IA en el instalador de Visual Studio.
Inicie sesión con su cuenta de GitHub que tenga una suscripción activa de GitHub Copilot
Configurar sus preferencias en Herramientas > Opciones > GitHub > Copilot y Herramientas > Opciones > Editor de texto > Sugerencias en línea

Nota:

GitHub Copilot requiere una suscripción (Individual, Empresarial o Enterprise). Algunas organizaciones proporcionan GitHub Copilot para sus desarrolladores como parte de su licencia de herramientas de desarrollo. También se puede usar una suscripción de GitHub Copilot con Visual Studio y VS Code.

Escribir código con sugerencias en línea

GitHub Copilot proporciona sugerencias a medida que escribe:

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

El texto fantasma gris muestra las sugerencias de GitHub Copilot. Presione Tab para aceptar o Esc para descartar.

Generación de procedimientos almacenados y funciones

Describir objetos de base de datos complejos en comentarios:

-- 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 comprende los patrones de procedimientos y genera código ejecutable completo.

Exploración del esquema de la base de datos

GitHub Copilot ayuda a escribir consultas para explorar la estructura de la base de datos:

-- 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 patrones de codificación del editor actual

GitHub Copilot sigue los patrones de codificación en el editor actual. Si usa convenciones de nomenclatura, formato o patrones específicos, GitHub Copilot los incorpora en sugerencias:

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

Esta coherencia hace que las sugerencias se sientan más naturales y reducen la necesidad de formato manual.

Aplicación de procedimientos recomendados de GitHub Copilot

Maximizar la eficacia de GitHub Copilot:

Práctica	Description
Escribir comentarios descriptivos	Los comentarios claros y específicos generan mejores sugerencias de código
Uso de nombres significativos	Los nombres descriptivos de tabla y columna ayudan a GitHub Copilot a comprender el contexto
Desglosar tareas complejas	Escribir varios comentarios para procedimientos complejos en lugar de un bloque grande
Revisar todas las sugerencias	Validar siempre el código generado para la corrección y la seguridad
Proporcionar ejemplos	Incluir datos de ejemplo o salida esperada en los comentarios
Revisar sugerencias continuamente	Si la primera sugerencia no es correcta, pruebe a modificar el comentario.

Consulta con lenguaje natural

Formule preguntas sobre los datos mediante inglés sin formato:

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

Dado que GitHub Copilot se conecta a la base de datos, genera código que funciona con su esquema específico.

Optimización del rendimiento de las consultas

GitHub Copilot analiza las consultas y sugiere mejoras:

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

Descripción y corrección de errores

Cuando se produce un error en las consultas, GitHub Copilot explica el problema y proporciona correcciones:

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

Obtener el máximo partido de GitHub Copilot

La ventana de chat de GitHub Copilot funciona sin una conexión de base de datos, pero es mucho más útil cuando tiene un editor de consultas abierto y conectado a una base de datos. Use GitHub Copilot para el desarrollo general de T-SQL, la finalización del código en el editor, la comprensión de la base de datos y el servidor, la optimización de consultas, etc.

Los desarrolladores pueden usar GitHub Copilot para la codificación diaria y responder a preguntas específicas de la base de datos, lo que ayuda a acelerar el desarrollo de bases de datos al tiempo que mantiene la calidad del código y aprovecha los procedimientos recomendados.

Comentarios

¿Le ha resultado útil esta página?