Partager via

Démarrage rapide : Utiliser l’Explorateur de schémas et le concepteur

Dans ce guide de démarrage rapide, vous allez découvrir comment GitHub Copilot aide les développeurs à concevoir, comprendre et évoluer des schémas de base de données avec des suggestions contextuelles. Que vous construisiez à partir de zéro ou que vous rétablissiez des tables existantes par ingénierie inverse, GitHub Copilot simplifie le processus dans les cadres SQL et de mappage objet-relationnel (ORM), rendant le travail sur le schéma plus rapide, plus intelligent et plus facile à gérer.

Cette section traite de la création de schémas à partir de zéro et de l’utilisation de bases de données existantes. Vous pouvez utiliser GitHub Copilot pour générer des définitions de schéma axées sur le code, mettre à jour des objets, faire de l'ingénierie inverse et explorer les bases de données existantes.

Création de schéma

Créer un schéma de base

Write a SQL script to create a new schema named `blog` for a blog application. The schema should include three tables: `Posts`, `Comments`, and `Users`. Each table must have appropriate primary keys, and the necessary foreign key relationships and constraints should be defined.

Modifier le schéma

Add a new column named `LastModified` of type `datetime` to the `Posts` table in the `blog` schema. Generate the updated SQL script reflecting this change, including the full definition of the modified schema.

It isn't needed to create the schema, but it would be great if you could use the script generated and run it to validate the accuracy of the generated code. The following section continues using this new schema called `blog`.

Créer un schéma avec des relations et des contraintes

Generate a Prisma schema for a blog application using my current database. The schema should define a new database schema named `blog` and include tables for `posts`, `authors`, and `comments`, with appropriate relationships and constraints.

Créer un script de migration pour ajouter une colonne

Generate a Prisma migration to add a column called `LastModified` (`datetime`) to the `Post` table.

Ingénierie inverse d’une base de données existante

Reverse engineer the current database and generate `CREATE TABLE` statements for all tables in the `SalesLT` schema.

Résumer une structure de tableau

Summarize the structure of the `SalesLT.Product` table in natural language.

Générer un modèle Python

Generate a `models.py` (Django) file that reflects the structure of the `SalesLT.Customer` table.

Générer un contexte et des modèles Entity Framework Core

Generate an Entity Framework Core DbContext and model classes for the `SalesLT` schema.

Créer une définition de modèle et des associations

Create a Sequelize model definition for the `SalesLT.Product` and `SalesLT.Category` tables with appropriate associations.

Générer une entité à partir d’une table

Generate a TypeORM entity for the `SalesLT.Customer` table, including primary key and indexed fields.

Générer un script de migration pour créer une nouvelle table

Generate a `knex.js` migration script to create the `SalesLT.SalesOrderHeader` table with `OrderDate`, `CustomerID`, and `TotalDue` columns.

Définir des relations

Définir un script relationnel avec des références de clé étrangère

Write SQL to define a one-to-many relationship between `Users` and `Posts` in the `blog` schema. Ensure the foreign key in `Posts` references `Users(UserId)`.

Ajouter une table à un schéma avec des références de clé étrangère

Add a `Categories` table to the `blog` schema and update the `Posts` table to include a nullable foreign key referencing `Categories(CategoryId)`.

Mettre à jour une base de données pour ajouter une table et mettre à jour des colonnes

Write SQL to update the `Users` table to include a `RoleId` column and create a new `Roles` table. Define a foreign key relationship and enforce that every user must have a role.

Identifier les relations de clé étrangère pour une table

Identify and describe all foreign key relationships that involve the `SalesLT.SalesOrderHeader` table.

Remplacer une clé étrangère par une relation plusieurs-à-plusieurs

Write a SQL script that removes a foreign key between `Posts` and `Categories` in the `blog` schema and replaces it with a many-to-many relationship using a new join table.

Générer un mappage entre deux tables

Write Prisma relation mappings between `Customer`, `SalesOrderHeader`, and `SalesOrderDetail`.

Mettre à jour un modèle de données

Update a Sequelize model to include a `hasMany` and `belongsTo` relationship between `Customer` and `Order`.

Validation du schéma

Suggérer des contraintes pour les données sensibles

Suggest constraints for a table storing user passwords (for example, special characters and length limits).

Valider les contraintes de type de données

Confirm that the `Name` column in `SalesLT.ProductCategory` doesn't use `nvarchar(max)` and has a reasonable maximum length constraint.

Valider les contraintes de clé primaire

Check whether the `SalesLT.Address` table has a primary key and all required fields defined.

Valider les enregistrements d’audit pour les tables

Generate a SQL script to validate that all tables in the `SalesLT` schema include a `CreatedDate` or `ModifiedDate` column.

Définir un modèle et inclure une logique de validation

Define a SQLAlchemy model for the `Customer` table and include validation logic using Pydantic or custom Python validators before inserting into the database.

Ajouter des annotations de données pour la validation de format

Add data annotations in an Entity Framework model to ensure fields like `Email` and `PhoneNumber` follow specific formats.

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 semblaient 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