Panduan Cepat: Asisten Pengoptimal Kueri

GitHub Copilot membantu pengembang mengoptimalkan kueri dan menganalisis hambatan performa tanpa memerlukan keahlian di internal database, terutama pengembang tanpa keahlian Transact-SQL mendalam (T-SQL). GitHub Copilot dapat memecah SQL yang kompleks, menginterpretasikan rencana eksekusi, dan menyarankan strategi pengindeksan atau peluang refaktor. Pengembang dapat menjaga aplikasi mereka tetap fungsional dan berkinerja, sambil tetap berfokus pada pengiriman fitur.

Mulai sekarang!

Pastikan Anda tersambung ke database dan membuka jendela editor aktif dengan ekstensi MSSQL. Saat Anda terhubung, @mssql peserta obrolan memahami konteks lingkungan database Anda dan dapat memberikan saran yang akurat dan sadar konteks. Jika Anda tidak tersambung ke database, peserta obrolan tidak 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. Awalan ini memastikan bahwa peserta obrolan memahami bahwa Anda meminta bantuan terkait SQL.

Optimalkan performa dengan GitHub Copilot

GitHub Copilot menawarkan beberapa cara untuk membantu pengembang menulis kode database berkinerja, siap produksi tanpa memerlukan keahlian mendalam dalam penyetelan kueri atau analisis rencana eksekusi. Baik Anda membangun fitur baru atau menyelidiki masalah performa, GitHub Copilot dapat memberikan wawasan, merekomendasikan pengoptimalan, dan membantu merestrukturisasi kueri. Anda dapat mengakses semua kemampuan ini dalam alur kerja yang ada di Visual Studio Code.

Bagian berikut ini menjelaskan kasus penggunaan umum dan contoh apa yang dapat Anda tanyakan melalui peserta obrolan.

Mengoptimalkan kueri

Gunakan GitHub Copilot untuk mengidentifikasi inefisiensi dalam kueri SQL atau pemetaan relasional objek (ORM) dan menyarankan cara untuk meningkatkan performa. GitHub Copilot membantu Anda menerapkan praktik terbaik T-SQL dan ORM, mulai dari menulis ulang kueri lambat hingga merekomendasikan indeks atau menghindari anti-pola seperti gabungan Kartesius, berdasarkan konteks Anda saat ini.

Contoh dasar

Optimize the following query:

SELECT *
FROM SalesLT.SalesOrderHeader
WHERE OrderDate > '2023-01-01';

Contoh peningkatan indeks

Suggest indexing improvements for this query:

SELECT ProductID
FROM SalesLT.SalesOrderDetail
WHERE Quantity > 100;

Contoh penyempurnaan gabungan

Rewrite this query to avoid a Cartesian join. Make sure the new query follows T-SQL best practices:

SELECT * FROM Customers, Order;

Contoh pilih berlapis

Rewrite this Prisma query to avoid unnecessary nested selects and improve readability:

const orders = await prisma.salesOrderHeader.findMany({
  where: {
    orderDate: {
      gt: new Date('2023-01-01')
    }
  }
});

Analisis rencana eksekusi

Rencana eksekusi memberikan perincian terperinci tentang cara mesin SQL memproses kueri. GitHub Copilot dapat membantu Anda menafsirkan rencana eksekusi, mengidentifikasi hambatan seperti gabungan perulangan berlapis, dan menyarankan peningkatan berdasarkan pola kueri dunia nyata dan strategi pengindeksan.

Anda dapat menggunakan kueri berikut sebagai contoh untuk menghasilkan rencana eksekusi menggunakan opsi Perkiraan/Paket aktual di ekstensi MSSQL:

SELECT soh1.SalesOrderID AS OrderA,
       soh2.SalesOrderID AS OrderB,
       soh1.TotalDue AS TotalA,
       soh2.TotalDue AS TotalB
FROM SalesLT.SalesOrderHeader AS soh1
    CROSS JOIN SalesLT.SalesOrderHeader AS soh2
WHERE soh1.TotalDue < soh2.TotalDue
ORDER BY soh2.TotalDue DESC;

Sertakan konteks sebanyak mungkin, dengan memilih kueri dari editor dan menyertakan sqlplan file di jendela obrolan GitHub Copilot, seperti yang ditunjukkan pada cuplikan layar ini.

According to the execution plan shared by my database expert, the following query is using a nested loop join which is affecting the performance of my app. Can you explain in simple terms why this might be happening? Additionally, suggest optimization strategies that could improve the query's performance.

Anda dapat menggunakan kueri berikut sebagai contoh untuk menghasilkan rencana eksekusi menggunakan opsi Perkiraan/Paket aktual di ekstensi MSSQL:

SELECT c1.CustomerID,
       c1.LastName,
       c2.CustomerID AS MatchingCustomerID,
       c2.LastName AS MatchingLastName
FROM SalesLT.Customer AS c1
     INNER JOIN SalesLT.Customer AS c2
         ON c1.LastName = c2.LastName
        AND c1.CustomerID <> c2.CustomerID
OPTION (LOOP JOIN);

Sertakan konteks sebanyak mungkin dengan memilih kueri dari editor dan menyertakan sqlplan file di jendela obrolan GitHub Copilot, seperti yang ditunjukkan pada cuplikan layar ini.

Explain the execution plan for this query that performs a join with a filter on TotalDue:

SELECT c.CustomerID,
       c.FirstName,
       c.LastName,
       soh.SalesOrderID,
       soh.TotalDue
FROM SalesLT.Customer AS c
     INNER JOIN SalesLT.SalesOrderHeader AS soh
         ON c.CustomerID = soh.CustomerID
WHERE soh.TotalDue > 500;

Restrukturisasi kueri

Merestrukturisasi kueri menggunakan ekspresi tabel umum (CTA) dapat membuat kueri Anda lebih mudah dibaca dan dikelola. Pendekatan ini sangat membantu untuk logika kompleks atau subkueri berlapis. GitHub Copilot dapat membantu Anda menulis ulang kueri yang ada untuk menggunakan CTE sambil mempertahankan niat asli dan meningkatkan kejelasan.

Pilih bagian dalam ke contoh CTE

Rewrite this query using common table expressions (CTEs) to improve clarity:

SELECT *
FROM (SELECT ProductID,
             SUM(Quantity) AS TotalQuantity
      FROM Sales
      GROUP BY ProductID) AS SubQuery;

Contoh klausa HAVING pada CTE

Rewrite the following query using a CTE (common table expression) to improve readability and maintainability:

SELECT soh.CustomerID,
       COUNT(*) AS OrderCount
FROM SalesLT.SalesOrderHeader AS soh
WHERE soh.OrderDate > '2022-01-01'
GROUP BY soh.CustomerID
HAVING COUNT(*) > 5;

Klausa agregasi pada contoh CTE

Use a CTE to separate the aggregation logic from the filter condition in this query:

SELECT ProductID,
       AVG(UnitPrice) AS AvgPrice
FROM SalesLT.SalesOrderDetail
GROUP BY ProductID
HAVING AVG(UnitPrice) > 50;

Skenario kinerja berbasis kode pertama

Saat Anda bekerja dengan ORM seperti Entity Framework, Prisma, atau Sequelize, performa dapat menurun jika Anda tidak mengoptimalkan kueri. GitHub Copilot membantu Anda mendeteksi dan mengatasi masalah seperti indeks yang hilang, pemfilteran yang tidak efisien, dan masalah N+1 dalam alur kerja code-first.

Contoh prisma

In a Prisma project, how would you ensure that queries filtering by `OrderDate` in `SalesOrderHeader` are using indexes effectively?

Contoh Inti Kerangka Kerja Entitas

Using Entity Framework Core, how can you analyze and optimize a LINQ query that retrieves the top 10 customers by total order value?

Contoh Sequelize

In Sequelize, how do you restructure a query that fetches order history with product details to minimize N+1 query issues?

Untuk membantu kami memperbaiki dan meningkatkan GitHub Copilot untuk ekstensi MSSQL, gunakan templat masalah GitHub berikut untuk mengirimkan umpan balik Anda: GitHub Copilot Feedback

Saat mengirimkan umpan balik, pertimbangkan untuk menyertakan:

Skenario yang diuji: Beri tahu kami area mana yang Anda fokuskan, misalnya, pembuatan skema, pembuatan kueri, keamanan, pelokalan.
Apa yang bekerja dengan baik: Jelaskan pengalaman apa pun yang terasa lancar, membantu, atau melebihi harapan Anda.
Masalah atau gangguan: Sertakan setiap masalah, inkonsistensi, atau perilaku yang membingungkan. Cuplikan layar atau rekaman layar sangat membantu.
Saran untuk perbaikan: Bagikan ide untuk meningkatkan kegunaan, memperluas cakupan, atau meningkatkan respons GitHub Copilot.

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-01-20