Rychlý start: Generování kódu

V tomto rychlém startu zjistíte, jak GitHub Copilot zrychluje vývoj SQL a relačního mapování objektů (ORM) generováním kódu pracujícího s kontextem přímo v editoru Visual Studio Code. GitHub Copilot vám pomůže vygenerovat tabulky, vyvíjet schémata a snižovat opakované skriptování. Ať už používáte T-SQL nebo pracujete s ORM, jako jsou Entity Framework, Sequelize, Prisma nebo SQLAlchemy, GitHub Copilot vám pomůže soustředit se na vytváření aplikační logiky.

Začínáme

Ujistěte se, že jste připojení k databázi a máte otevřené okno aktivního editoru s rozšířením MSSQL. Toto připojení umožňuje účastníkovi @mssql chatu porozumět kontextu vašeho databázového prostředí a umožnit přesné a kontextové návrhy. Bez připojení k databázi nebude účastník chatu mít schéma ani datový kontext, aby poskytoval smysluplné odpovědi.

Následující příklady používají AdventureWorksLT2022 ukázkovou databázi, kterou si můžete stáhnout z domovské stránky Ukázky microsoft SQL Serveru a projekty komunity .

Nejlepších výsledků dosáhnete, když upravíte názvy tabulek a schémat tak, aby odpovídaly vašemu vlastnímu prostředí.

Ujistěte se, že chat obsahuje předponu @mssql . Například zadejte @mssql svůj dotaz nebo výzvu. Tím zajistíte, že účastník chatu pochopí, že žádáte o pomoc související s SQL.

Generování kódu pomocí GitHub Copilotu

Pomocí GitHub Copilotu vygenerujte kód kompatibilní s SQL a ORM, který odráží strukturu připojené databáze a dodržuje osvědčené postupy. Od definování tabulek a relací až po skriptování zobrazení, vytváření migračních souborů nebo generování vrstev přístupu k datům a rozhraní API vám GitHub Copilot pomůže pracovat rychleji a s větší jistotou.

Tady jsou běžné případy použití a příklady toho, co se můžete zeptat prostřednictvím účastníka chatu:

Generování kódu SQL

GitHub Copilot vám může pomoct generovat kód SQL pro několik vývojových scénářů, od skriptování, vytváření a úpravy tabulek až po zápis uložených procedur a zobrazení. Tyto příklady ukazují, jak můžete pomocí GitHub Copilotu automatizovat opakované skriptování SQL a postupovat podle osvědčených postupů pro vývoj T-SQL.

Skriptování všech tabulek ve schématu

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

Načtení zákaznických dat pomocí uložené procedury

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.

Skriptování tabulky se všemi omezeními a indexy

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

Vytvořte skript pro zobrazení, které spojí dvě tabulky

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.

Změna tabulky přidáním nového sloupce

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

Generování migrací ORM

GitHub Copilot může generovat migrace kompatibilní s ORM a definice modelu na základě kontextu schématu a zvolené architektury. Od Sequelize do Entity Frameworku, Prisma a SQLAlchemy pomáhá GitHub Copilot vygenerovat změny, které odpovídají datovému modelu vaší aplikace.

Vygenerování modelu pro přidání sloupce

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

Generování třídy modelu Entity Framework

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

Generování modelu Entity Framework

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

Napsání kódu Pythonu pro definování tabulky

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

Zápis parametrizovaného dotazu

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

Aktualizace existujícího modelu pro přidání tabulky

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

Generování třídy modelu pro tabulku

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

Generování šablonového kódu aplikace

GitHub Copilot může také pomoct vygenerovat back-endové a front-endové komponenty, které pracují s vaší databází SQL. Tyto příklady ukazují, jak můžete přejít ze schématu na funkční kód aplikace pomocí oblíbených zásobníků, jako jsou Azure Functions, Node.js, Django a Next.js.

SQL vazby pro bezserverový backend a Blazor

Následující příklad ukazuje úplné výzvy, které můžete použít s GitHub Copilot Chat k vygenerování kompletního řešení. Tyto výzvy obsahují podrobné pokyny a kontext, které pomáhají copilotu generovat přesný a strukturovaný kód napříč back-endovou i front-endovou vrstvou.

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.

Kompletní zásobník s Node.js a Next.js

Následující příklad je podrobná výzva, kterou můžete zadat v GitHub Copilot Chatu a vygenerovat úplné nastavení back-endu, včetně tras rozhraní API a integrace databáze.

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