Mulai cepat: Membuat kode

Dalam panduan cepat ini, Anda mempelajari bagaimana GitHub Copilot mempercepat pengembangan SQL dan pemetaan hubungan objek (ORM) dengan menghasilkan kode yang sesuai dengan konteks secara langsung di Visual Studio Code. GitHub Copilot membantu Anda menerapkan tabel dasar, mengembangkan skema, dan mengurangi pembuatan skrip berulang. Baik Anda menggunakan T-SQL, atau bekerja dengan ORM seperti Entity Framework, Sequelize, Prisma, atau SQLAlchemy, GitHub Copilot membantu Anda fokus membangun logika aplikasi.

Mulai sekarang!

Pastikan Anda tersambung ke database dan membuka jendela editor aktif dengan ekstensi MSSQL. Koneksi ini memungkinkan @mssql peserta obrolan untuk memahami konteks lingkungan database Anda, memungkinkan saran yang akurat dan sadar konteks. Tanpa koneksi database, peserta obrolan tidak akan memiliki skema atau konteks data untuk memberikan respons yang bermakna.

Contoh berikut menggunakan AdventureWorksLT2022 database sampel, yang dapat Anda unduh dari beranda Sampel Microsoft SQL Server dan Proyek Komunitas .

Untuk hasil terbaik, sesuaikan nama tabel dan skema agar sesuai dengan lingkungan Anda sendiri.

Pastikan obrolan menyertakan awalan @mssql . Misalnya, ketik @mssql diikuti dengan pertanyaan atau perintah Anda. Ini memastikan bahwa peserta obrolan memahami Bahwa Anda meminta bantuan terkait SQL.

Pembuatan kode dengan GitHub Copilot

Gunakan GitHub Copilot untuk menghasilkan kode yang kompatibel dengan SQL dan ORM yang mencerminkan struktur database yang terhubung dan mengikuti praktik terbaik. Dari menentukan tabel dan hubungan hingga menulis skrip tampilan, membangun file migrasi, atau membangun kerangka lapisan akses data dan API, GitHub Copilot membantu Anda bergerak lebih cepat dan dengan lebih percaya diri.

Berikut adalah kasus penggunaan umum dan contoh apa yang dapat Anda tanyakan melalui peserta obrolan:

Hasilkan kode SQL

GitHub Copilot dapat membantu Anda menghasilkan kode SQL untuk beberapa skenario pengembangan, dari pembuatan skrip, membuat dan memodifikasi tabel hingga menulis prosedur dan tampilan tersimpan. Contoh-contoh ini menggambarkan bagaimana Anda dapat menggunakan GitHub Copilot untuk mengotomatiskan pembuatan skrip SQL berulang dan mengikuti praktik terbaik untuk pengembangan T-SQL.

Membuat skrip semua tabel dalam skema

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

Mengambil data pelanggan dengan prosedur tersimpan

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.

Membuat skrip tabel dengan semua batasan dan indeks

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

Membuat skrip tampilan yang menggabungkan dua tabel

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.

Mengubah tabel dengan menambahkan kolom baru

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

Membuat migrasi ORM

GitHub Copilot dapat menghasilkan migrasi dan definisi model yang kompatibel dengan ORM berdasarkan konteks skema dan kerangka pilihan Anda. Dari Sequelize ke Entity Framework, Prisma, dan SQLAlchemy, GitHub Copilot membantu menyusun perubahan yang selaras dengan model data aplikasi Anda.

Membuat model untuk menambahkan kolom

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

Menghasilkan kelas model Entity Framework

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

Hasilkan model Kerangka Kerja Entitas

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

Menulis kode Python untuk menentukan tabel

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

Menulis kueri berparameter

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

Memperbarui model yang sudah ada untuk menambahkan tabel

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

Membuat kelas model untuk tabel

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

Membuat kode aplikasi boilerplate

GitHub Copilot juga dapat membantu membangun kerangka komponen backend dan frontend yang berinteraksi dengan database SQL Anda. Contoh-contoh ini menunjukkan bagaimana Anda dapat berubah dari skema ke kode aplikasi yang berfungsi menggunakan tumpukan populer seperti Azure Functions, Node.js, Django, dan Next.js.

Pengikatan SQL backend tanpa server dan Blazor

Contoh berikut memperlihatkan prompt lengkap yang dapat Anda gunakan dengan GitHub Copilot Chat untuk mengembangkan solusi end-to-end. Perintah ini mencakup instruksi dan konteks terperinci untuk membantu Copilot menghasilkan kode terstruktur yang akurat di seluruh lapisan backend dan 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.

Full-stack dengan Node.js dan Next.js

Contoh berikut adalah perintah terperinci yang dapat Anda berikan di GitHub Copilot Chat untuk menghasilkan penyiapan backend lengkap, termasuk rute API dan integrasi database.

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