Partager via

Démarrage rapide : Générer du code

Dans ce démarrage rapide, vous allez découvrir comment GitHub Copilot accélère le développement SQL et de mappage objet-relationnel (ORM) en générant du code conscient du contexte directement dans Visual Studio Code. GitHub Copilot vous aide à esquisser des tables, à faire évoluer des schémas et à diminuer les scripts répétitifs. Que vous utilisiez T-SQL ou que vous utilisiez des orms comme Entity Framework, Sequelize, Prisma ou SQLAlchemy, GitHub Copilot vous aide à vous concentrer sur la création d’une logique d’application.

Commencez

Vérifiez que vous êtes connecté à une base de données et que vous disposez d’une fenêtre d’éditeur active ouverte avec l’extension MSSQL. Cette connexion permet au @mssql participant au chat de comprendre le contexte de votre environnement de base de données, ce qui permet des suggestions précises et adaptées au contexte. Sans connexion de base de données, le participant de conversation ne dispose pas du schéma ou du contexte de données pour fournir des réponses significatives.

Les exemples suivants utilisent l’exemple AdventureWorksLT2022 de base de données, que vous pouvez télécharger à partir de la page d’accueil Exemples microsoft SQL Server et Projets communautaires .

Pour obtenir de meilleurs résultats, ajustez les noms de table et de schéma pour qu’ils correspondent à votre propre environnement.

Assurez-vous que la conversation inclut le @mssql préfixe. Par exemple, tapez @mssql suivi de votre question ou de votre invite. Cela garantit que le participant de conversation comprend que vous demandez de l’aide liée à SQL.

Génération de code avec GitHub Copilot

Utilisez GitHub Copilot pour générer du code compatible SQL et ORM qui reflète la structure de votre base de données connectée et suit les meilleures pratiques. De la définition de tables et de relations aux vues de script, à la création de fichiers de migration ou à la génération de couches et d’API d’accès aux données, GitHub Copilot vous permet de passer plus rapidement et en toute confiance.

Voici des cas d’usage courants et des exemples de ce que vous pouvez demander via le participant de conversation :

Générer du code SQL

GitHub Copilot peut vous aider à générer du code SQL pour plusieurs scénarios de développement, à partir du script, de la création et de la modification de tables à l’écriture de procédures stockées et de vues. Ces exemples illustrent comment utiliser GitHub Copilot pour automatiser les scripts SQL répétitifs et suivre les meilleures pratiques pour le développement T-SQL.

Générer un script pour toutes les tables d’un schéma

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

Récupérer des données client avec une procédure stockée

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.

Créer un script pour une table avec toutes les contraintes et indices

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

Scripter une vue qui joint deux tables

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.

Modifier une table en ajoutant une nouvelle colonne

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

Générer des migrations ORM

GitHub Copilot peut générer des migrations compatibles ORM et des définitions de modèles en fonction de votre contexte de schéma et de votre infrastructure de choix. De Sequelize à Entity Framework, Prisma et SQLAlchemy, GitHub Copilot aide à élaborer des modifications qui correspondent au modèle de données de votre application.

Générer un modèle pour ajouter une colonne

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

Générer une classe de modèle Entity Framework

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

Générer un modèle Entity Framework

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

Écrire du code Python pour définir une table

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

Écrire une requête paramétrable

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

Mettre à jour le modèle existant pour ajouter une table

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

Générer une classe de modèle pour une table

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

Générer du code standard d’application

GitHub Copilot peut également aider à générer des modèles principaux et frontaux qui interagissent avec votre base de données SQL. Ces exemples montrent comment passer du schéma au code d’application opérationnel à l’aide de piles populaires telles qu’Azure Functions, Node.js, Django et Next.js.

Liaisons SQL serverless back-end et Blazor

L’exemple suivant montre des commandes complètes que vous pouvez utiliser avec GitHub Copilot Chat pour mettre en place une structure d'une solution complète. Ces invites incluent des instructions détaillées et un contexte pour aider Copilot à générer du code précis et structuré à travers les couches backend et 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.

Développement full-stack avec Node.js et Next.js

L’exemple suivant est une invite détaillée que vous pouvez fournir dans GitHub Copilot Chat pour générer l’installation complète du back-end, notamment les itinéraires d’API et l’intégration de base de données.

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

L’exemple suivant est une invite détaillée que vous pouvez fournir dans GitHub Copilot Chat pour générer l’installation complète du back-end, notamment les itinéraires d’API et l’intégration de base de données.

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

Partager votre expérience

Pour nous aider à affiner et améliorer GitHub Copilot pour l’extension MSSQL, utilisez le modèle de problème GitHub suivant pour envoyer vos commentaires : Commentaires GitHub Copilot

Lors de l’envoi de commentaires, envisagez d’inclure :

  • Scénarios testés : informez-nous des domaines sur lesquels vous vous êtes concentré, par exemple, la création de schéma, la génération de requêtes, la sécurité, la localisation.

  • Ce qui a bien fonctionné – Décrivez toutes les expériences qui ont semblé fluides, utiles ou ont dépassé vos attentes.

  • Problèmes ou bogues : incluez des problèmes, des incohérences ou des comportements déroutants. Les captures d’écran ou les enregistrements d’écran sont particulièrement utiles.

  • Suggestions d’amélioration : partagez des idées pour améliorer la facilité d’utilisation, développer la couverture ou améliorer les réponses de GitHub Copilot.

Contenu connexe

  • Last updated on