Schnellstart: Generieren von Code

In dieser Schnellstartanleitung erfahren Sie, wie GitHub Copilot die SQL- und objektrelationale Zuordnung (ORM)-Entwicklung beschleunigt, indem Sie kontextabhängigen Code direkt in Visual Studio Code generieren. GitHub Copilot hilft Ihnen, Gerüsttabellen zu erstellen, Schemas zu entwickeln und sich wiederholende Skripts zu reduzieren. Ganz gleich, ob Sie T-SQL verwenden oder mit ORMs wie Entity Framework, Sequelize, Prisma oder SQLAlchemy arbeiten, GitHub Copilot hilft Ihnen beim Erstellen von Anwendungslogik.

Loslegen

Stellen Sie sicher, dass Sie mit einer Datenbank verbunden sind und ein aktives Editorfenster mit der MSSQL-Erweiterung geöffnet ist. Diese Verbindung ermöglicht es dem @mssql Chatteilnehmer, den Kontext Ihrer Datenbankumgebung zu verstehen und präzise und kontextbezogene Vorschläge zu ermöglichen. Ohne Datenbankverbindung verfügt der Chatteilnehmer nicht über das Schema oder den Datenkontext, um aussagekräftige Antworten bereitzustellen.

In den folgenden Beispielen wird die AdventureWorksLT2022 Beispieldatenbank verwendet, die Sie auf der Startseite von Microsoft SQL Server-Beispielen und Communityprojekten herunterladen können.

Um optimale Ergebnisse zu erzielen, passen Sie Tabellen- und Schemanamen an Ihre eigene Umgebung an.

Stellen Sie sicher, dass der Chat das @mssql Präfix enthält. Geben Sie @mssql z. B. gefolgt von Ihrer Frage oder Aufforderung ein. Dadurch wird sichergestellt, dass der Chatteilnehmer versteht, dass Sie sql-bezogene Unterstützung anfordern.

Codegenerierung mit GitHub Copilot

Verwenden Sie GitHub Copilot, um SQL- und ORM-kompatiblen Code zu generieren, der die Struktur Ihrer verbundenen Datenbank widerspiegelt und bewährte Methoden befolgt. Von der Definition von Tabellen und Beziehungen zu Skriptansichten, zum Erstellen von Migrationsdateien oder zum Erstellen von Gerüsten für Datenzugriffsebenen und APIs hilft GitHub Copilot Ihnen, schneller und vertrauenswürdiger zu arbeiten.

Nachfolgend finden Sie häufige Anwendungsfälle und Beispiele dafür, was Sie über den Chatteilnehmer fragen können:

SQL-Code generieren

GitHub Copilot kann Ihnen helfen, SQL-Code für mehrere Entwicklungsszenarien zu generieren, von Skripting, Erstellen und Ändern von Tabellen bis hin zum Schreiben gespeicherter Prozeduren und Ansichten. Diese Beispiele veranschaulichen, wie Sie GitHub Copilot verwenden können, um sich wiederholende SQL-Skripts zu automatisieren und bewährte Methoden für die T-SQL-Entwicklung zu befolgen.

Skripten Sie alle Tabellen in einem Schema aus

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

Abrufen von Kundendaten mit einer gespeicherten Prozedur

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.

Ein Skript für eine Tabelle mit allen Einschränkungen und Indizes erstellen

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

Schreiben eines Skripts zur Erstellung einer Ansicht, die zwei Tabellen verknüpft

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.

Ändern einer Tabelle durch Hinzufügen einer neuen Spalte

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

Generieren von ORM-Migrationen

GitHub Copilot kann ORM-kompatible Migrationen und Modelldefinitionen basierend auf Ihrem Schemakontext und dem von Ihnen gewählten Framework generieren. Von Sequelize zu Entity Framework, Prisma und SQLAlchemy unterstützt GitHub Copilot Gerüständerungen, die am Datenmodell Ihrer Anwendung ausgerichtet sind.

Generieren eines Modells zum Hinzufügen einer Spalte

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

Entity Framework-Modellklasse generieren

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

Entity Framework-Modell generieren

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

Schreiben von Python-Code zum Definieren einer Tabelle

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

Schreiben einer parametrisierten Abfrage

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

Aktualisieren eines vorhandenen Modells zum Hinzufügen einer Tabelle

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

Generieren einer Modellklasse für eine Tabelle

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

Vorlagen-Code für Apps generieren

GitHub Copilot kann auch beim Erstellen von Back-End- und Frontend-Komponenten helfen, die mit Ihrer SQL-Datenbank interagieren. Diese Beispiele zeigen, wie Sie von Schema zu funktionierendem Anwendungscode mit beliebten Stapeln wie Azure Functions, Node.js, Django und Next.jswechseln können.

Serverless Back-End SQL-Bindungen und Blazor

Das folgende Beispiel zeigt vollständige Eingabeaufforderungen, die Sie mit GitHub Copilot Chat verwenden können, um eine End-to-End-Lösung zu erstellen. Diese Eingabeaufforderungen enthalten detaillierte Anweisungen und Kontext, um Copilot dabei zu unterstützen, präzisen, strukturierten Code auf Back-End- und Frontend-Ebenen zu generieren.

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 mit Node.js und Next.js

Das folgende Beispiel ist eine detaillierte Eingabeaufforderung, die Sie in GitHub Copilot Chat bereitstellen können, um das vollständige Back-End-Setup zu generieren, einschließlich API-Routen und Datenbankintegration.

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: Django + Django REST Framework

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

Um uns dabei zu helfen, GitHub Copilot für die MSSQL-Erweiterung zu verfeinern und zu verbessern, verwenden Sie die folgende GitHub-Problemvorlage, um Ihr Feedback zu übermitteln: GitHub Copilot Feedback

Berücksichtigen Sie bei der Übermittlung von Feedback Folgendes:

Getestete Szenarien – Teilen Sie uns mit, auf welche Bereiche Sie sich konzentrieren, z. B. Schemaerstellung, Abfragegenerierung, Sicherheit, Lokalisierung.
Was gut funktioniert hat – Beschreiben Sie alle Erfahrungen, die sich reibungslos, hilfreich fühlen oder Ihre Erwartungen überschritten haben.
Probleme oder Fehler – Schließen Sie alle Probleme, Inkonsistenzen oder verwirrende Verhaltensweisen ein. Screenshots oder Bildschirmaufzeichnungen sind besonders hilfreich.
Verbesserungsvorschläge – Teilen Sie Ideen zur Verbesserung der Benutzerfreundlichkeit, zur Erweiterung der Abdeckung oder zur Verbesserung der Antworten von GitHub Copilot.

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-19