Quickstart: Code genereren

In deze quickstart leert u hoe GitHub Copilot sql- en object-relationele toewijzingsontwikkeling (ORM) versnelt door contextbewuste code rechtstreeks in Visual Studio Code te genereren. GitHub Copilot helpt u bij het ontwikkelen van tabellen, het ontwikkelen van schema's en het verminderen van terugkerende scripts. Of u nu T-SQL gebruikt of werkt met ORM's zoals Entity Framework, Sequelize, Prisma of SQLAlchemy, GitHub Copilot helpt u zich te concentreren op het bouwen van toepassingslogica.

Aan de slag

Zorg ervoor dat u verbinding hebt met een database en een actief editorvenster hebt geopend met de MSSQL-extensie. Met deze verbinding kan de @mssql chatdeelnemer de context van uw databaseomgeving begrijpen en nauwkeurige en contextbewuste suggesties inschakelen. Zonder een databaseverbinding beschikt de chatdeelnemer niet over het schema of de gegevenscontext om zinvolle antwoorden te geven.

In de volgende voorbeelden wordt de AdventureWorksLT2022 voorbeelddatabase gebruikt, die u kunt downloaden van de startpagina van Microsoft SQL Server Samples en Community Projects .

Pas voor de beste resultaten de tabel- en schemanamen aan zodat deze overeenkomen met uw eigen omgeving.

Zorg ervoor dat de chat het @mssql voorvoegsel bevat. Typ bijvoorbeeld @mssql gevolgd door uw vraag of prompt. Dit zorgt ervoor dat de chatdeelnemer begrijpt dat u vraagt om hulp met betrekking tot SQL.

Codegeneratie met GitHub Copilot

Gebruik GitHub Copilot om sql- en ORM-compatibele code te genereren die overeenkomt met de structuur van uw verbonden database en de aanbevolen procedures te volgen. Van het definiëren van tabellen en relaties met scriptweergaven, het bouwen van migratiebestanden of het maken van gegevenstoegangslagen en API's, helpt GitHub Copilot u sneller en met meer vertrouwen te bewegen.

Hier volgen veelvoorkomende gebruiksvoorbeelden en voorbeelden van wat u kunt vragen via de chatdeelnemer:

SQL-code genereren

GitHub Copilot kan u helpen bij het genereren van SQL-code voor verschillende ontwikkelscenario's, van scripting, het maken en wijzigen van tabellen tot het schrijven van opgeslagen procedures en weergaven. In deze voorbeelden ziet u hoe u GitHub Copilot kunt gebruiken om terugkerende SQL-scripts te automatiseren en aanbevolen procedures voor T-SQL-ontwikkeling te volgen.

Alle tabellen in een schema scripten

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

Klantgegevens ophalen met een opgeslagen procedure

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.

Een tabel met alle beperkingen en indexen uitvoeren

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

Een weergave uitvoeren waarmee twee tabellen worden samengevoegd

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.

Een tabel wijzigen door een nieuwe kolom toe te voegen

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

ORM-migraties genereren

GitHub Copilot kan orm-compatibele migraties en modeldefinities genereren op basis van uw schemacontext en framework van keuze. Van Sequelize tot Entity Framework, Prisma en SQLAlchemy helpt GitHub Copilot bij het opzetten van wijzigingen die zijn afgestemd op het gegevensmodel van uw toepassing.

Een model genereren om een kolom toe te voegen

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

Entity Framework-modelklasse genereren

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

Entity Framework-model genereren

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

Python-code schrijven om een tabel te definiëren

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

Een geparameteriseerde query schrijven

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

Bestaand model bijwerken om een tabel toe te voegen

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

Een modelklasse genereren voor een tabel

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

Standaard-app-code genereren

GitHub Copilot kan ook helpen bij het opzetten van back-end- en front-end-componenten die met uw SQL-database communiceren. Deze voorbeelden laten zien hoe u van schema naar toepassingscode kunt gaan met behulp van populaire stacks zoals Azure Functions, Node.js, Django en Next.js.

Serverloze back-end-SQL-bindingen en Blazor

In het volgende voorbeeld ziet u de volledige aanwijzingen die u met GitHub Copilot Chat kunt gebruiken om een end-to-end-oplossing te maken. Deze prompts bevatten gedetailleerde instructies en context om Copilot te helpen nauwkeurige, gestructureerde code te genereren in zowel back-end- als front-endlagen.

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.

Volledige stack met Node.js en Next.js

Het volgende voorbeeld is een gedetailleerde prompt die u kunt opgeven in GitHub Copilot Chat om de volledige back-endinstallatie te genereren, waaronder API-routes en databaseintegratie.

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