Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Membuat dan menafsirkan rencana kueri

Anda dapat menggunakan paket kueri untuk mendapatkan informasi tentang operasi individual yang diperlukan untuk menjalankan kueri. Sebelum Anda bekerja dengan paket kueri, sebaiknya Anda terlebih dahulu memahami cara Amazon Redshift menangani kueri pemrosesan dan membuat paket kueri. Untuk informasi selengkapnya, lihat Perencanaan kueri dan alur kerja eksekusi.

Untuk membuat rencana kueri, jalankan EXPLAIN perintah diikuti oleh teks kueri yang sebenarnya. Paket kueri memberi Anda informasi berikut:

EXPLAINPerintah tidak benar-benar menjalankan kueri. Ini hanya menunjukkan paket yang dijalankan Amazon Redshift jika kueri dijalankan dalam kondisi operasi saat ini. Jika Anda mengubah skema atau data untuk tabel dan menjalankannya ANALYZE lagi untuk memperbarui metadata statistik, rencana kueri mungkin berbeda.

Output rencana kueri EXPLAIN adalah tampilan eksekusi kueri tingkat tinggi yang disederhanakan. Itu tidak menggambarkan detail pemrosesan query paralel. Untuk melihat informasi terperinci, jalankan kueri itu sendiri, lalu dapatkan informasi ringkasan kueri dari REPORT tampilan SVL QUERY _ SVL _ SUMMARY atau QUERY _ _. Untuk informasi selengkapnya tentang menggunakan tampilan ini, lihatMenganalisis ringkasan kueri.

Contoh berikut menunjukkan EXPLAIN output untuk query GROUP BY sederhana di atas EVENT meja:

explain select eventname, count(*) from event group by eventname;

                            QUERY PLAN
-------------------------------------------------------------------
XN HashAggregate  (cost=131.97..133.41 rows=576 width=17)
  ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=17)

EXPLAINmengembalikan metrik berikut untuk setiap operasi:

EXPLAINoperator

Bagian ini menjelaskan secara singkat operator yang paling sering Anda lihat di EXPLAIN output. Untuk daftar lengkap operator, lihat EXPLAIN di bagian SQL Perintah.

Operator pemindaian berurutan

Operator pemindaian sekuensial (Seq Scan) menunjukkan pemindaian tabel. Seq Scan memindai setiap kolom dalam tabel secara berurutan dari awal hingga akhir dan mengevaluasi kendala kueri (dalam klausa) untuk setiap baris. WHERE

Bergabunglah dengan operator

Amazon Redshift memilih operator gabungan berdasarkan desain fisik tabel yang digabungkan, lokasi data yang diperlukan untuk bergabung, dan persyaratan spesifik kueri itu sendiri.

Operator agregat

Paket kueri menggunakan operator berikut dalam kueri yang melibatkan fungsi agregat dan operasi GROUP BY.

Mengurutkan operator

Paket kueri menggunakan operator berikut ketika kueri harus mengurutkan atau menggabungkan kumpulan hasil.

UNION,INTERSECT, dan EXCEPT operator

Paket kueri menggunakan operator berikut untuk kueri yang melibatkan operasi set denganUNION,INTERSECT, danEXCEPT.

Operator lainnya

Operator berikut juga sering muncul dalam EXPLAIN output untuk kueri rutin.

Bergabung EXPLAIN

Pengoptimal kueri menggunakan jenis gabungan yang berbeda untuk mengambil data tabel, tergantung pada struktur kueri dan tabel yang mendasarinya. EXPLAINOutput mereferensikan tipe gabungan, tabel yang digunakan, dan cara data tabel didistribusikan di seluruh cluster untuk menggambarkan bagaimana kueri diproses.

Contoh tipe gabungan

Contoh berikut menunjukkan berbagai jenis gabungan yang dapat digunakan oleh pengoptimal kueri. Jenis gabungan yang digunakan dalam rencana kueri tergantung pada desain fisik tabel yang terlibat.

Contoh: Hash bergabung dengan dua tabel

Kueri berikut bergabung EVENT dan CATEGORY di CATID kolom. CATIDadalah kunci distribusi dan sortir untuk CATEGORY tetapi tidak untukEVENT. Gabungan hash dilakukan dengan EVENT sebagai meja luar dan CATEGORY sebagai tabel bagian dalam. Karena tabel yang CATEGORY lebih kecil, perencana menyiarkan salinannya ke node komputasi selama pemrosesan kueri dengan menggunakan DS_ _. BCAST INNER Biaya bergabung dalam contoh ini menyumbang sebagian besar biaya kumulatif paket.

explain select * from category, event where category.catid=event.catid;

                               QUERY PLAN
-------------------------------------------------------------------------
 XN Hash Join DS_BCAST_INNER  (cost=0.14..6600286.07 rows=8798 width=84)
   Hash Cond: ("outer".catid = "inner".catid)
   ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=35)
   ->  XN Hash  (cost=0.11..0.11 rows=11 width=49)
         ->  XN Seq Scan on category  (cost=0.00..0.11 rows=11 width=49)

Contoh: Gabung bergabung dengan dua tabel

Kueri berikut juga menggunakan SELECT *, tetapi bergabung SALES dan LISTING pada LISTID kolom, di mana LISTID telah ditetapkan sebagai distribusi dan kunci pengurutan untuk kedua tabel. Gabungan gabungan dipilih, dan tidak diperlukan redistribusi data untuk bergabung (DS_ _DIST). NONE

explain select * from sales, listing where sales.listid = listing.listid;
QUERY PLAN
-----------------------------------------------------------------------------
XN Merge Join DS_DIST_NONE  (cost=0.00..6285.93 rows=172456 width=97)
  Merge Cond: ("outer".listid = "inner".listid)
  ->  XN Seq Scan on listing  (cost=0.00..1924.97 rows=192497 width=44)
  ->  XN Seq Scan on sales  (cost=0.00..1724.56 rows=172456 width=53)

Contoh berikut menunjukkan berbagai jenis gabungan dalam query yang sama. Seperti pada contoh sebelumnya, SALES dan LISTING bergabung bergabung, tetapi tabel ketiga,EVENT, harus hash bergabung dengan hasil gabungan gabungan. Sekali lagi, bergabung hash menimbulkan biaya siaran.

explain select * from sales, listing, event
where sales.listid = listing.listid and sales.eventid = event.eventid;
                                  QUERY PLAN
----------------------------------------------------------------------------
XN Hash Join DS_BCAST_INNER  (cost=109.98..3871130276.17 rows=172456 width=132)
  Hash Cond: ("outer".eventid = "inner".eventid)
  ->  XN Merge Join DS_DIST_NONE  (cost=0.00..6285.93 rows=172456 width=97)
        Merge Cond: ("outer".listid = "inner".listid)
        ->  XN Seq Scan on listing  (cost=0.00..1924.97 rows=192497 width=44)
        ->  XN Seq Scan on sales  (cost=0.00..1724.56 rows=172456 width=53)
  ->  XN Hash  (cost=87.98..87.98 rows=8798 width=35)
        ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=35)

Contoh: Gabung, agregat, dan urutkan

Kueri berikut menjalankan gabungan hash dari EVENT tabel SALES dan, diikuti oleh agregasi dan operasi pengurutan untuk memperhitungkan SUM fungsi yang dikelompokkan dan klausa BY. ORDER Operator pengurutan awal berjalan secara paralel pada node komputasi. Kemudian operator Jaringan mengirimkan hasilnya ke node pemimpin, di mana operator Merge menghasilkan hasil akhir yang diurutkan.

explain select eventname, sum(pricepaid) from sales, event 
where sales.eventid=event.eventid group by eventname
order by 2 desc;
                                           QUERY PLAN
---------------------------------------------------------------------------------
 XN Merge  (cost=1002815366604.92..1002815366606.36 rows=576 width=27)
  Merge Key: sum(sales.pricepaid)
  ->  XN Network  (cost=1002815366604.92..1002815366606.36 rows=576 width=27)
        Send to leader
        ->  XN Sort  (cost=1002815366604.92..1002815366606.36 rows=576 width=27)
              Sort Key: sum(sales.pricepaid)
              ->  XN HashAggregate  (cost=2815366577.07..2815366578.51 rows=576 width=27)
                    ->  XN Hash Join DS_BCAST_INNER  (cost=109.98..2815365714.80 rows=172456 width=27)
                          Hash Cond: ("outer".eventid = "inner".eventid)
                          ->  XN Seq Scan on sales  (cost=0.00..1724.56 rows=172456 width=14)
                          ->  XN Hash  (cost=87.98..87.98 rows=8798 width=21)
                                ->  XN Seq Scan on event  (cost=0.00..87.98 rows=8798 width=21)

Redistribusi data

EXPLAINOutput untuk gabungan juga menentukan metode untuk bagaimana data dipindahkan di sekitar cluster untuk memfasilitasi gabungan. Pergerakan data ini dapat berupa siaran atau redistribusi. Dalam siaran, nilai data dari satu sisi gabungan disalin dari setiap node komputasi ke setiap node komputasi lainnya, sehingga setiap node komputasi berakhir dengan salinan data yang lengkap. Dalam redistribusi, nilai data yang berpartisipasi dikirim dari irisan mereka saat ini ke irisan baru (mungkin pada node yang berbeda). Data biasanya didistribusikan ulang agar sesuai dengan kunci distribusi dari tabel lain yang berpartisipasi dalam gabungan jika kunci distribusi itu adalah salah satu kolom yang bergabung. Jika tidak satu pun dari tabel memiliki kunci distribusi pada salah satu kolom yang bergabung, baik kedua tabel didistribusikan atau tabel bagian dalam disiarkan ke setiap node.

EXPLAINOutputnya juga mereferensikan tabel dalam dan luar. Tabel bagian dalam dipindai terlebih dahulu, dan muncul lebih dekat di bagian bawah rencana kueri. Meja bagian dalam adalah meja yang diperiksa untuk korek api. Biasanya disimpan dalam memori, biasanya tabel sumber untuk hashing, dan jika mungkin, adalah tabel yang lebih kecil dari keduanya yang bergabung. Tabel luar adalah sumber baris yang cocok dengan meja bagian dalam. Biasanya dibaca dari disk. Pengoptimal kueri memilih tabel bagian dalam dan luar berdasarkan statistik database dari perintah terbaru. ANALYZE Urutan tabel dalam FROM klausa kueri tidak menentukan tabel mana yang dalam dan mana yang luar.

Gunakan atribut berikut dalam rencana kueri untuk mengidentifikasi bagaimana data dipindahkan untuk memfasilitasi kueri: