Início Rápido: Gerar código

Neste início rápido, você aprenderá como o GitHub Copilot acelera o desenvolvimento de SQL e orM (mapeamento relacional de objeto) gerando código com reconhecimento de contexto diretamente no Visual Studio Code. O GitHub Copilot ajuda você a estruturar tabelas, desenvolver esquemas e reduzir scripts repetitivos. Se você estiver usando o T-SQL ou trabalhando com ORMs como Entity Framework, Sequelize, Prisma ou SQLAlchemy, o GitHub Copilot ajuda você a se concentrar na criação da lógica do aplicativo.

Introdução

Verifique se você está conectado a um banco de dados e abra uma janela do editor ativo com a extensão MSSQL. Essa conexão permite que o participante do @mssql chat entenda o contexto do ambiente do banco de dados, permitindo sugestões precisas e com reconhecimento de contexto. Sem uma conexão de banco de dados, o participante do chat não terá o esquema ou o contexto de dados para fornecer respostas significativas.

Os exemplos a seguir usam o banco de dados de exemplo AdventureWorksLT2022, que você pode baixar na página inicial dos Exemplos e Projetos da Comunidade do Microsoft SQL Server.

Para obter melhores resultados, ajuste os nomes de tabela e esquema para corresponder ao seu próprio ambiente.

Verifique se o chat inclui o @mssql prefixo. Por exemplo, digite @mssql seguido de sua pergunta ou instrução. Isso garante que o participante do chat entenda que você está solicitando assistência relacionada ao SQL.

Geração de código com o GitHub Copilot

Use o GitHub Copilot para gerar código compatível com SQL e ORM que reflete a estrutura do banco de dados conectado e segue as práticas recomendadas. Desde definir tabelas e relações até exibições de script, criar arquivos de migração ou estruturar camadas de acesso a dados e APIs, o GitHub Copilot ajuda você a se mover mais rápido e com maior confiança.

Aqui estão casos de uso comuns e exemplos do que você pode perguntar por meio do participante do chat:

Gerar código SQL

O GitHub Copilot pode ajudá-lo a gerar código SQL para vários cenários de desenvolvimento, desde scripts, criação e modificação de tabelas até a gravação de procedimentos armazenados e exibições. Estes exemplos ilustram como você pode usar o GitHub Copilot para automatizar o script SQL repetitivo e seguir as práticas recomendadas para o desenvolvimento do T-SQL.

Criar script de todas as tabelas em um esquema

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

Recuperar dados do cliente com um procedimento armazenado

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.

Criar script de uma tabela com todas as restrições e índices

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

Escrever um script de uma visualização que une duas tabelas

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.

Alterar uma tabela adicionando uma nova coluna

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

Gerar migrações de ORM

O GitHub Copilot pode gerar migrações e definições de modelo compatíveis com ORM com base no contexto de esquema e na estrutura de sua escolha. De Sequelize para Entity Framework, Prisma e SQLAlchemy, o GitHub Copilot ajuda a estruturar alterações que se alinham ao modelo de dados do aplicativo.

Gerar um modelo para adicionar uma coluna

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

Gerar classe de modelo do Entity Framework

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

Gerar modelo do Entity Framework

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

Escrever código Python para definir uma tabela

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

Gravar uma consulta parametrizada

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

Atualizar o modelo existente para adicionar uma tabela

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

Gerar uma classe de modelo para uma tabela

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

Gerar código de aplicativo modelo

O GitHub Copilot também pode ajudar a estruturar componentes de back-end e front-end que interagem com o banco de dados SQL. Estes exemplos mostram como você pode ir do esquema para o código do aplicativo de trabalho usando pilhas populares como Azure Functions, Node.js, Django e Next.js.

Associações SQL de back-end sem servidor e Blazor

O exemplo a seguir mostra os prompts completos que você pode usar com o GitHub Copilot Chat para estruturar uma solução de ponta a ponta. Esses prompts incluem instruções detalhadas e contexto para ajudar o Copilot a gerar código preciso e estruturado em camadas de back-end e 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.

Desenvolvimento full-stack com Node.js e Next.js

O exemplo a seguir é um prompt detalhado que você pode fornecer no GitHub Copilot Chat para gerar a configuração completa de back-end, incluindo rotas de API e integração de banco de dados.

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: Django + Django REST framework