Snabbstart: Generera kod

I den här snabbstarten får du lära dig hur GitHub Copilot påskyndar utvecklingen av SQL- och objektrelationsmappning (ORM) genom att generera kontextmedveten kod direkt i Visual Studio Code. GitHub Copilot hjälper dig att skapa tabeller, utveckla scheman och minska repetitiva skript. Oavsett om du använder T-SQL eller arbetar med ORM:er som Entity Framework, Sequelize, Prisma eller SQLAlchemy hjälper GitHub Copilot dig att fokusera på att skapa programlogik.

Kom igång

Kontrollera att du är ansluten till en databas och har ett aktivt redigeringsfönster öppet med MSSQL-tillägget. Med den @mssql här anslutningen kan chattdeltagaren förstå kontexten för din databasmiljö, vilket möjliggör korrekta och sammanhangsmedvetna förslag. Utan en databasanslutning har chattdeltagaren inte schemat eller datakontexten för att ge meningsfulla svar.

I följande exempel används exempeldatabasen AdventureWorksLT2022 , som du kan ladda ned från startsidan microsoft SQL Server-exempel och communityprojekt .

För bästa resultat justerar du tabell- och schemanamn så att de matchar din egen miljö.

Kontrollera att chatten innehåller prefixet @mssql . Skriv till exempel @mssql följt av din fråga eller begäran. Detta säkerställer att chattdeltagaren förstår att du ber om SQL-relaterad hjälp.

Kodgenerering med GitHub Copilot

Använd GitHub Copilot för att generera SQL- och ORM-kompatibel kod som återspeglar den anslutna databasens struktur och följer metodtipsen. Från att definiera tabeller och relationer till skriptvyer, skapa migreringsfiler eller skapa kodningslager för dataåtkomst och API:er hjälper GitHub Copilot dig att gå snabbare och med större förtroende.

Här är vanliga användningsfall och exempel på vad du kan fråga via chattdeltagaren:

Generera SQL-kod

GitHub Copilot kan hjälpa dig att generera SQL-kod för flera utvecklingsscenarier, från skriptning, skapande och ändring av tabeller till att skriva lagrade procedurer och vyer. De här exemplen illustrerar hur du kan använda GitHub Copilot för att automatisera repetitiva SQL-skript och följa metodtips för T-SQL-utveckling.

Skripta ut alla tabeller i ett schema

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

Hämta kunddata med en lagrad procedur

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.

Skripta ut en tabell med alla begränsningar och index

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

Skripta ut en vy som kopplar ihop två tabeller

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.

Ändra en tabell genom att lägga till en ny kolumn

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

Generera ORM-migreringar

GitHub Copilot kan generera ORM-kompatibla migreringar och modelldefinitioner baserat på valfritt schemakontext och ramverk. Från Sequelize till Entity Framework, Prisma och SQLAlchemy hjälper GitHub Copilot till att skapa ändringar som överensstämmer med programmets datamodell.

Generera en modell för att lägga till en kolumn

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

Generera Entity Framework-modellklass

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

Generera Entity Framework-modell

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

Skriva Python-kod för att definiera en tabell

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

Skriva en parametriserad fråga

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

Uppdatera befintlig modell för att lägga till en tabell

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

Generera en modellklass för en tabell

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

Generera programkod för boilerplate

GitHub Copilot kan också hjälpa till att skapa backend- och klientdelskomponenter som interagerar med din SQL-databas. De här exemplen visar hur du kan gå från schema till fungerande programkod med hjälp av populära staplar som Azure Functions, Node.js, Django och Next.js.

Serverlösa SQL-bindningar för serverdelen och Blazor

I följande exempel visas fullständiga uppmaningar som du kan använda med GitHub Copilot Chat för att bygga en komplett lösning. Dessa uppmaningar innehåller detaljerade instruktioner och kontext för att hjälpa Copilot att generera korrekt, strukturerad kod i både serverdels- och klientdelslager.

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.

Fullstack med Node.js och Next.js

Följande exempel är en detaljerad fråga som du kan ange i GitHub Copilot Chat för att generera den fullständiga serverdelskonfigurationen, inklusive API-vägar och databasintegrering.

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.

Serverdel: Django + Django REST Framework