Inicio rápido: Generación de código

En esta guía de inicio rápido, obtendrá información sobre cómo GitHub Copilot acelera el desarrollo de SQL y mapeo objeto-relacional (ORM) mediante la generación de código contextualizado directamente en Visual Studio Code. GitHub Copilot ayuda a estructurar las tablas, modificar esquemas y reducir el scripting repetitivo. Tanto si usa T-SQL como si trabaja con ORM como Entity Framework, Sequelize, Prisma o SQLAlchemy, GitHub Copilot le ayuda a centrarse en la creación de lógica de aplicaciones.

Comienza

Asegúrese de que está conectado a una base de datos y de que tiene abierta una ventana del editor activa con la extensión MSSQL. Esta conexión permite al participante del @mssql chat comprender el contexto del entorno de base de datos, lo que permite sugerencias precisas y compatibles con el contexto. Sin una conexión de base de datos, el participante del chat no tendrá el esquema ni el contexto de datos para proporcionar respuestas significativas.

En los ejemplos siguientes se usa la AdventureWorksLT2022 base de datos de ejemplo, que puede descargar desde la página principal Ejemplos de Microsoft SQL Server y Proyectos de comunidad .

Para obtener los mejores resultados, ajuste los nombres de tabla y esquema para que coincidan con su propio entorno.

Asegúrese de que el chat incluye el @mssql prefijo. Por ejemplo, escriba @mssql seguido de su pregunta o indicador. Esto garantiza que el participante del chat comprenda que solicita ayuda relacionada con SQL.

Generación de código con GitHub Copilot

Use GitHub Copilot para generar código compatible con SQL y ORM que refleje la estructura de la base de datos conectada y siga los procedimientos recomendados. Desde la definición de tablas y relaciones a la creación de vistas mediante scripting, la elaboración de archivos de migración o la creación automática de capas y APIs de acceso a datos, GitHub Copilot le ayuda a moverse más rápido y con mayor confianza.

Estos son casos de uso comunes y ejemplos de lo que puede preguntar a través del participante del chat:

Generación de código SQL

GitHub Copilot puede ayudarle a generar código SQL para varios escenarios de desarrollo, desde el scripting, la creación y modificación de tablas para escribir procedimientos almacenados y vistas. Estos ejemplos muestran cómo puede usar GitHub Copilot para automatizar el scripting repetitivo de SQL y seguir los procedimientos recomendados para el desarrollo de T-SQL.

Generar script de todas las tablas en un esquema

Script out all the tables in the `SalesLT` schema as `CREATE TABLE` statements in SQL.

Recuperación de datos de clientes con un procedimiento almacenado

Write a SQL stored procedure in my current database. The procedure should retrieve all customers from the `SalesLT.Customer` table where the `LastName` matches a given parameter. Make sure to use T-SQL best practices.

Generar un script que liste una tabla con todas las restricciones e índices

Script out the `SalesLT.Customer` table as a `CREATE TABLE` statement, including all constraints and indexes.

Escribir un script para una vista que une dos tablas

Generate a SQL script to create a view that joins the `SalesLT.Customer` and `SalesLT.SalesOrderHeader` tables, showing customer names and their total order amounts.

Modificar una tabla agregando una nueva columna

Write a SQL script to alter the `SalesLT.Customer` table by adding a `last_updated` column with a default timestamp.

Generar migraciones ORM

GitHub Copilot puede generar migraciones y definiciones de modelo compatibles con ORM en función del contexto de esquema y del marco de trabajo que prefiera. Desde Sequelize a Entity Framework, Prisma y SQLAlchemy, GitHub Copilot ayuda a aplicar scaffolding a los cambios que se alinean con el modelo de datos de la aplicación.

Generación de un modelo para agregar una columna

Generate a Sequelize (JavaScript) model to add an `email` column (`varchar(256)`) to the `SalesLT.Customer` table.

Generación de la clase de modelo de Entity Framework

Generate an Entity Framework model class in C# to represent a `SalesLT.ProductModel` table with `id`, `name`, and `description` columns.

Generación de un modelo de Entity Framework

Generate an Entity Framework model in C# based on the existing `SalesLT.Product` table.

Escritura de código de Python para definir una tabla

Write SQLAlchemy code to define a `SalesLT.OrderDetails` table with `id`, `order_date`, and `customer_id` fields, ensuring compatibility with `Python`.

Escritura de una consulta con parámetros

Using SQLAlchemy, write a parameterized query that retrieves all customers from the `SalesLT.Customer` table where the `LastName` matches a provided parameter.

Actualización del modelo existente para agregar una tabla

Update my existing Prisma model (schema.prisma) to define a new `SalesLT.Order` model with `id`, `customer_id`, and `order_date` fields.

Generación de una clase de modelo para una tabla

Generate a SQLAlchemy model class for the `SalesLT.Product` table, including columns and data types.

Generar código de aplicación estándar

GitHub Copilot también puede ayudar a estructurar los componentes de backend y frontend que interactúan con la base de datos SQL. En estos ejemplos se muestra cómo puede pasar del esquema al código de aplicación en funcionamiento mediante pilas populares como Azure Functions, Node.js, Django y Next.js.

Enlaces SQL de back-end sin servidor y Blazor

En el ejemplo siguiente se muestran prompts completos que puede usar con GitHub Copilot Chat para estructurar una solución de un extremo a otro. Estos avisos incluyen instrucciones detalladas y contexto para ayudar a Copilot a generar código preciso y estructurado en capas de back-end y front-end.

Generate a full-stack app using Azure SQL bindings for Functions and Blazor WebAssembly. Follow these steps:

1. Backend: Azure Functions (C#) with SQL Bindings

   - Configure SQL Bindings to automatically read and write data from the `SalesLT.Customer` table.
   - Implement HTTP-triggered functions with the following endpoints:
     - `GET /api/customers` – Fetch all customers.
     - `GET /api/customers/{id}` – Get a specific customer by ID.
     - `POST /api/customers` – Create a new customer.
     - `PUT /api/customers/{id}` – Update an existing customer.
     - `DELETE /api/customers/{id}` – Delete a customer.
   - Use `Dependency Injection` for database connections and logging.
   - Include an `appsettings.json` file to store database connection strings and environment variables.
   - Use `Azure Functions Core Tools` to run and test the functions locally.

1. Frontend: Blazor WebAssembly (Optional)

   - Create a Blazor WebAssembly frontend that consumes the API.
   - Display a table with customer data and a form to add new customers.
   - Use `HttpClient` to call the Azure Functions endpoints.
   - Implement two-way data binding to handle form inputs dynamically.
   - Use Bootstrap or Blazor components for styling and layout.

Ensure the project includes setup instructions for running both the Azure Functions backend and Blazor WebAssembly frontend locally, with proper `.env` or `local.settings.json` configurations for database connections.

Pila completa con Node.js y Next.js

El ejemplo siguiente es un aviso detallado que puede proporcionar en El chat de Copilot de GitHub para generar la configuración de back-end completa, incluidas las rutas de API y la integración de bases de datos.

Generate a REST API using Node.js with Express that connects to my local SQL Database. Use the Tedious package for SQL Server connections and Prisma as the ORM. Follow these steps:

1. Backend: Node.js + Express

   - Establish a database connection using Prisma with Tedious as the SQL Server driver.
   - Implement API routes for `SalesLT.Customer` with the following endpoints:
     - `GET /customers` – Fetch all customers.
     - `GET /customers/:id` – Get a specific customer by ID.
     - `POST /customers` – Create a new customer.
     - `PUT /customers/:id` – Update an existing customer.
     - `DELETE /customers/:id` – Delete a customer.
   - Configure `Prisma` to map the `SalesLT.Customer` table and generate database migrations using `prisma migrate dev`.
   - Use `dotenv` for environment variables (database credentials, ports, etc.).
   - Add `Jest` for testing the API endpoints.

1. Frontend: Next.js + TypeScript (Optional)

   - Create a Next.js frontend that consumes the API.
   - Display a table with customer data and a form to add new customers.
   - Use React hooks (`useState`, `useEffect`) to manage state and fetch data dynamically.
   - Style the UI using Tailwind CSS.
   - Implement server-side data fetching (`getServerSideProps`) in Next.js for improved performance.

Ensure the project includes setup instructions for running both the backend and frontend independently, with proper `.env` configurations for the database connection.

Back-end: Marco REST de Django + Django

Scaffold a Django backend with Django REST Framework for the `SalesLT.Customer` table. Follow these steps:

- Implement API routes using Django's `ModelViewSet` with the following endpoints:
  - `GET /customers` – Fetch all customers.
  - `GET /customers/{id}` – Get a specific customer by ID.
  - `POST /customers` – Create a new customer.
  - `PUT /customers/{id}` – Update an existing customer.
  - `DELETE /customers/{id}` – Delete a customer.

- Add instructions for generating database migrations with `python manage.py makemigrations` and `migrate`.

Para ayudarnos a refinar y mejorar GitHub Copilot para la extensión MSSQL, use la siguiente plantilla de problema de GitHub para enviar sus comentarios: Comentarios de GitHub Copilot

Al enviar comentarios, considere la posibilidad de incluir:

Escenarios probados : háganos saber en qué áreas se ha centrado, por ejemplo, la creación de esquemas, la generación de consultas, la seguridad, la localización.
Lo que funcionó bien : describa cualquier experiencia que se sintiera suave, útil o superara sus expectativas.
Problemas o errores : incluya cualquier problema, incoherencias o comportamientos confusos. Las capturas de pantalla o las grabaciones de pantalla son especialmente útiles.
Sugerencias para mejorar : comparta ideas para mejorar la facilidad de uso, expandir la cobertura o mejorar las respuestas de GitHub Copilot.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-11-19