Rövid útmutató: Kód létrehozása

Ebben a rövid útmutatóban megtudhatja, hogyan gyorsítja fel a GitHub Copilot az SQL és az objektum-relációs leképezés (ORM) fejlesztését úgy, hogy környezetfüggő kódot hoz létre közvetlenül a Visual Studio Code-ban. A GitHub Copilot segítségével táblákat hozhat létre, sémákat fejleszthet, és csökkentheti az ismétlődő szkriptek használatát. Függetlenül attól, hogy Transact-SQL (T-SQL) vagy objektum-relációs leképezési (ORM-) keretrendszerekkel( Entity Framework, Sequelize, Prisma vagy SQLAlchemy) dolgozik, GitHub Copilot segít az alkalmazáslogika létrehozására összpontosítani.

Első lépések

Győződjön meg arról, hogy csatlakozik egy adatbázishoz, és meg van nyitva egy aktív szerkesztőablak az MSSQL kiterjesztéssel. Amikor csatlakozik, a @mssql csevegés résztvevői megértik az adatbázis-környezet kontextusát, és pontos, környezettudatos javaslatokat tehetnek. Ha nem csatlakozik adatbázishoz, a csevegés résztvevője nem rendelkezik a sémával vagy az adatkörnyezettel, hogy értelmes válaszokat adjon.

Az alábbi példák a AdventureWorksLT2022 mintaadatbázist használják, amelyet a Microsoft SQL Server-minták és közösségi projektek kezdőlapjáról tölthet le.

A legjobb eredmény érdekében módosítsa a táblázat- és sémaneveket a saját környezetének megfelelően.

Győződjön meg arról, hogy a csevegés tartalmazza az @mssql előtagot. Például írja be @mssql, majd adja meg a kérdést vagy felkérést. Ez az előtag biztosítja, hogy a csevegés résztvevője megértse, hogy SQL-hez kapcsolódó segítséget kér.

Kódlétrehozás a GitHub Copilottal

A GitHub Copilot használatával olyan SQL- és ORM-kompatibilis kódot hozhat létre, amely tükrözi a csatlakoztatott adatbázis struktúráját, és követi az ajánlott eljárásokat. A táblák és kapcsolatok definiálásától a szkriptelési nézetekig, a migrálási fájlok készítéséig vagy az adatelérési rétegek és API-k állványzatának kialakításáig a GitHub Copilot segít gyorsabban és magabiztosabban mozogni.

Az alábbiakban gyakori használati eseteket és példákat talál arra, hogy mit kérdezhet meg a csevegő résztvevőn keresztül:

SQL-kód létrehozása

A GitHub Copilot segítségével SQL-kódot hozhat létre több fejlesztési forgatókönyvhöz, a táblák szkriptelésétől, létrehozásán és módosításán át a tárolt eljárások és nézetek írásához. Ezek a példák bemutatják, hogyan automatizálhatja az ismétlődő SQL-szkriptelést a GitHub Copilot használatával, és hogyan követheti a T-SQL-fejlesztés ajánlott eljárásait.

Séma összes táblájának szkriptje

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

Ügyféladatok lekérése tárolt eljárással

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.

A táblázat kiszkriptelése az összes megszorítással és indexszel

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

Két táblát összekapcsoló nézet szkriptelése

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.

Táblázat módosítása új oszlop hozzáadásával

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

ORM-migrálások létrehozása

A GitHub Copilot ORM-kompatibilis migrálásokat és modelldefiníciókat hozhat létre a sémakörnyezet és a választott keretrendszer alapján. Az Entity Framework, a Prisma és az SQLAlchemy szekvenálásától kezdve a GitHub Copilot segít az alkalmazás adatmodelljéhez igazodó módosítások összeállításában.

Modell létrehozása oszlop hozzáadásához

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

Entity Framework-modellosztály létrehozása

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

Entity Framework-modell létrehozása

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

Python-kód írása tábla definiálásához

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

Paraméteres lekérdezés írása

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

Meglévő modell frissítése táblázat hozzáadásához

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

Modellosztály létrehozása egy táblához

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

Boilerplate alkalmazáskód generálása

A GitHub Copilot az SQL-adatbázissal együttműködő háttér- és előtér-összetevők összeállításában is segít. Ezek a példák bemutatják, hogyan válthat a sémáról a működő alkalmazáskódra olyan népszerű veremekkel, mint az Azure Functions, a Node.js, a Django és a Next.js.

Kiszolgáló nélküli háttérbeli SQL-kötések és Blazor

Az alábbi példa a GitHub Copilot Chattel használható teljes körű utasításokat mutat be egy teljes körű megoldás összeállításához. Ezek a kérések részletes utasításokat és kontextust tartalmaznak, amelyek segítségével a Copilot pontos, strukturált kódot hozhat létre a háttér- és előtérrétegek között.

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 fejlesztés Node.js és Next.js

Az alábbi példa egy részletes kérés, amelyet a GitHub Copilot Chatben adhat meg a háttérrendszer teljes beállításának létrehozásához, beleértve az API-útvonalakat és az adatbázis-integrációt.

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.

Háttérrendszer: Django + Django REST-keretrendszer

Az alábbi példa egy részletes kérés, amelyet a GitHub Copilot Chatben adhat meg a háttérrendszer teljes beállításának létrehozásához, beleértve az API-útvonalakat és az adatbázis-integrációt.

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

Ossza meg tapasztalatait

Az MSSQL-bővítményHez tartozó GitHub Copilot pontosításához és fejlesztéséhez használja a következő GitHub-problémasablont a visszajelzés elküldéséhez: GitHub Copilot Feedback

Visszajelzés küldésekor fontolja meg a következőket:

  • Tesztelt forgatókönyvek: Tudassa velünk, hogy mely területekre összpontosított, például sémalétrehozásra, lekérdezésgenerálásra, biztonságra, honosításra.

  • Ami jól működött: Ismertesse azokat a tapasztalatokat, amelyek zökkenőmentesnek, hasznosnak mutattak, vagy amelyek meghaladták az Ön elvárásait.

  • Problémák vagy hibák: Tartalmazzon bármilyen problémát, következetlenséget vagy zavaró viselkedést. A képernyőképek és a képernyőfelvételek különösen hasznosak.

  • Fejlesztési javaslatok: Ötletek megosztása a használhatóság javítására, a lefedettség bővítésére vagy a GitHub Copilot válaszainak javítására.

Kapcsolódó tartalom

  • Last updated on