Quickstart: Gerar código

Neste quickstart, aprende como o GitHub Copilot acelera o desenvolvimento de SQL e mapeamento objeto-relacional (ORM) ao gerar código contextual diretamente dentro do Visual Studio Code. O GitHub Copilot ajuda-te a criar tabelas, evoluir esquemas e reduzir o scripting repetitivo. Quer estejas a usar T-SQL, ou a trabalhar com ORMs como Entity Framework, Sequelize, Prisma ou SQLAlchemy, o GitHub Copilot ajuda-te a focar-te na construção de lógica de aplicações.

Introdução

Verifique se você está conectado a um banco de dados e se uma janela do editor ativo está aberta com a extensão MSSQL. Essa conexão permite que o participante do bate-papo @mssql compreenda o contexto do seu ambiente de banco de dados, permitindo sugestões precisas e sensíveis ao contexto. Sem uma conexão de banco de dados, o participante do bate-papo não terá o esquema ou o contexto de dados para fornecer respostas significativas.

Os exemplos a seguir usam o AdventureWorksLT2022 banco de dados de exemplo, que você pode baixar da home page de Exemplos e Projetos da Comunidade do Microsoft SQL Server .

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

Certifique-se de que o chat inclui o prefixo @mssql . Por exemplo, digite @mssql seguido de a sua pergunta ou solicitação. Isso garante que o participante do bate-papo 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 reflita a estrutura do banco de dados conectado e siga as práticas recomendadas. Desde a definição de tabelas e relacionamentos até o scripting de views, criação de arquivos de migração ou estruturação de camadas de acesso a dados e APIs, o GitHub Copilot ajuda a avançar mais rapidamente e com maior confiança.

Aqui estão casos de uso comuns e exemplos do que você pode perguntar através do participante do bate-papo:

Gerar código SQL

O GitHub Copilot pode ajudar-te a gerar código SQL para vários cenários de desenvolvimento, desde scripting, criação e modificação de tabelas até à escrita de procedimentos armazenados e vistas. Estes exemplos ilustram como você pode usar o GitHub Copilot para automatizar scripts SQL repetitivos e seguir as práticas recomendadas para o desenvolvimento T-SQL.

Gerar scripts para todas as tabelas em um esquema

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

Recuperar dados de clientes através de 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.

Crie um script numa tabela com todas as restrições e índices

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

Escreva um script de uma vista 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.

Altere 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 ORM

O GitHub Copilot pode gerar migrações compatíveis com ORM e definições de modelo com base no seu esquema, contexto e estrutura de escolha. Do Sequelize ao Entity Framework, Prisma e SQLAlchemy, o GitHub Copilot ajuda a organizar alterações que se alinham com o modelo de dados do seu 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.

Geração da classe de modelo 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.

Escreva 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`.

Escrever 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.

Atualize 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 modelo para uma tabela

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

Gerar código de aplicação modelo

O GitHub Copilot também pode ajudar a criar componentes de back-end e front-end que interagem com seu 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.

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

O exemplo seguinte mostra os prompts completos que pode usar com o GitHub Copilot Chat para apoiar uma solução de ponta a ponta. Esses prompts incluem instruções detalhadas e contexto para ajudar o Copilot a gerar código estruturado e preciso nas camadas de back-end e frontend.

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.

Full-stack com Node.js e Next.js

O exemplo seguinte é um prompt detalhado que pode fornecer no GitHub Copilot Chat para gerar a configuração completa do backend, incluindo rotas de API e integração com bases 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.

Backend: estrutura Django + Django REST